upload

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Jinheng Xie
+
+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.

README.md

@@ -1,13 +1,65 @@
----
-title: VISOR GPT
-emoji: 🔥
-colorFrom: yellow
-colorTo: pink
-sdk: gradio
-sdk_version: 3.32.0
-app_file: app.py
-pinned: false
-license: mit
----
+<div align=center>
+<img src="visorgpt_title.png" width="400">
+</div>
+
+## Learning Visual Prior via Generative Pre-Training [[Arxiv](http://arxiv.org/abs/2305.13777)] [[Demo]()] [[Video](https://www.youtube.com/watch?v=8FDoBfxSY8I)]
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+<img src="demo.gif" width="1000">
+
+## Updates
+- Gradio demo is available.
+- [Hugging Face demo will be available]().
+
+## Quick Start
+### Step 1
+```
+# clone the repo
+git clone https://github.com/Sierkinhane/VisorGPT.git
+
+# go to directory
+cd VisorGPT
+
+# create a new environment
+conda create -n visorgpt python=3.8
+
+# activate the new environment
+conda activate visorgpt
+
+# prepare the basic environments
+pip3 install -r requirements.txt
+
+# install controlnet and gligen
+cd demo/ControlNet
+pip3 install -v -e .
+cd ../demo/GLIGEN
+pip3 install -v -e .
+```
+### Step 2 - Download pre-trained weights
+Download [visorgpt](https://drive.google.com/file/d/1Pk4UPNKBMH-0uRLmK5COYTca7FUrN8XY/view?usp=share_link), [controlnet-pose2img](https://huggingface.co/lllyasviel/ControlNet-v1-1/blob/main/control_v11p_sd15_openpose.pth), [controlnet-sd](https://huggingface.co/runwayml/stable-diffusion-v1-5/blob/main/v1-5-pruned-emaonly.safetensors), [gligen-bbox2img](https://huggingface.co/gligen/gligen-generation-text-box/blob/main/diffusion_pytorch_model.bin), and put them as follow:
+```
+├── demo/
+|   ├── ckpts
+|   |   ├── controlnet
+|   |   |   ├── control_v11p_sd15_openpose.pth
+|   |   |   ├── v1-5-pruned-emaonly.safetensors
+|   |   ├── gligen
+|   |   |   ├── diffusion_pytorch_model_box.bin
+|   |   ├── visorgpt
+|   |   |   ├── visorgpt_dagger_ta_tb.pt
+```
+
+### Step 3 - Run demo
+```
+CUDA_VISIBLE_DEVICES=0 python3 gradio_demo.py
+```
+
+If you are using our code, please consider citing our paper.
+
+```
+@article{xie2023visorgpt,
+  title={VisorGPT: Learning Visual Prior via Generative Pre-Training},
+  author={Xie, Jinheng and Ye, Kai and Li, Yudong and Li, Yuexiang and Lin, Kevin Qinghong and Zheng, Yefeng and Shen, Linlin and Shou, Mike Zheng},
+  journal={arXiv preprint arXiv:2305.13777},
+  year={2023}
+}
+```

app.py

@@ -0,0 +1,425 @@
+from share import *
+import gradio as gr
+import numpy as np
+import torch
+import re
+from PIL import Image
+from tqdm import tqdm
+from train.scripts.generate_lm_multiple import gen_sequence, build_visorgpt
+from utils.seq2coord import gen_cond_mask
+from gligen.gligen_inference_box import gligen_infer, build_gligen_model
+from controlnet.gradio_pose2image_v2 import control_infer, build_control_model, build_controlv11_model
+
+# init models 
+visorgpt_config_path = 'train/models/gpt2/config.json'
+visorgpt_model_path = 'demo/ckpts/visorgpt/visorgpt_dagger_ta_tb.pt'
+visorgpt_vocab_path = 'train/models/google_uncased_en_coord_vocab.txt'
+
+# control_model_path = 'demo/ckpts/controlnet/control_sd15_openpose.pth'
+control_model_path = 'demo/ckpts/controlnet/control_v11p_sd15_openpose.pth' # v1.1
+control_sd_path = 'demo/ckpts/controlnet/v1-5-pruned-emaonly.safetensors'
+control_model_config = 'demo/ckpts/controlnet/cldm_v15.yaml'
+
+gligen_model_path = 'demo/ckpts/gligen/diffusion_pytorch_model_box.bin'
+
+
+visorgpt_args, visorgpt_model = build_visorgpt(model_config=visorgpt_config_path,
+                                                  model_path=visorgpt_model_path,
+                                                  vocab_path=visorgpt_vocab_path)
+control_model, ddim_sampler = build_controlv11_model(model_path=control_model_path,
+                                                     sd_path=control_sd_path,
+                                                  config_path=control_model_config)
+
+# build gligen model
+g_model, g_autoencoder, g_text_encoder, g_diffusion, \
+    g_config, g_grounding_tokenizer_input = build_gligen_model(ckpt=gligen_model_path)
+
+
+# maximum number of instances
+max_num_keypoint = 16
+max_num_bbox = 16
+max_num_mask = 8
+
+def generate_sequence(gen_type, 
+                        data_type,
+                        instance_size,
+                        num_instance, 
+                        object_name_inbox):
+
+    ctn = True
+
+    if gen_type == 'key point':
+        num_keypoint = 18
+        if num_instance > max_num_keypoint:
+            num_instance = max_num_keypoint
+
+        seq_prompt = '; '.join([gen_type, data_type, instance_size, str(num_instance), str(num_keypoint)]) + ' ; [person'
+
+    elif gen_type == 'box' or gen_type == 'mask':
+
+        if not object_name_inbox.strip():
+            if gen_type == 'mask':
+                object_name_inbox = "bottle; cup"
+            else:
+                if data_type == 'object centric':
+                    object_name_inbox = "great white shark"
+                else:
+                    object_name_inbox = "person; frisbee"
+
+        num_keypoint = 0
+
+        if gen_type == 'mask':
+            if num_instance > max_num_mask:
+                num_instance = max_num_mask
+        if gen_type == 'box':
+            if num_instance > max_num_bbox:
+                num_instance = max_num_bbox
+
+        if data_type == 'object centric':
+            num_instance = 1
+
+        objects = ', '.join(object_name_inbox.strip().split(";"))
+        seq_prompt = '; '.join([gen_type, data_type, instance_size,
+                                str(num_instance), str(num_keypoint)]) + '; ' + objects
+
+        if len(object_name_inbox.split(';')) > num_instance:
+            return {
+                raw_sequence: gr.update(
+                    value="The umber of category names should be less than the number of instances, please try again :)",
+                    visible=True)
+            }
+
+    print("input prompt: \n", seq_prompt)
+    sequence = gen_sequence(visorgpt_args, visorgpt_model, seq_prompt)
+    assert isinstance(sequence, list)
+
+    try:
+        cond_mask, cond_json = gen_cond_mask(sequence, ctn)
+        if gen_type == 'key point':
+            ori_sequence = cond_json[2]['sequences'][0][0] + '[SEP]'
+        elif gen_type == 'box':
+            ori_sequence = cond_json[0]['sequences'][0][0] + '[SEP]'
+        elif gen_type == 'mask':
+            ori_sequence = cond_json[1]['sequences'][0][0] + '[SEP]'        
+    except:
+        cond_mask, cond_json = gen_cond_mask(sequence, not ctn)    
+        if gen_type == 'key point':
+            ori_sequence = cond_json[2]['sequences'][0][0] + '[SEP]'
+        elif gen_type == 'box':
+            ori_sequence = cond_json[0]['sequences'][0][0] + '[SEP]'
+        elif gen_type == 'mask':
+            ori_sequence = cond_json[1]['sequences'][0][0] + '[SEP]'        
+
+    ret_img = Image.fromarray(cond_mask)
+
+    if not gen_type == 'mask':
+        return {
+            result_gallery: [ret_img],
+            raw_sequence: gr.update(value=ori_sequence, visible=True),
+            images_button: gr.update(visible=True),
+            text_container: cond_json,
+            sequence_container: ori_sequence
+        }
+    else:
+        return {
+            result_gallery: [ret_img],
+            raw_sequence: gr.update(value=ori_sequence, visible=True),
+            images_button: gr.update(visible=False),
+            text_container: cond_json,
+            sequence_container: ori_sequence
+        }        
+    
+def add_contents(gen_type, 
+                        data_type,
+                        instance_size,
+                        num_instance, 
+                        object_name_inbox,
+                        num_continuous_gen,
+                        global_seq):
+
+    ctn = True
+
+    if gen_type == 'key point':
+        num_keypoint = 18
+        seq_prompt = '; '.join([gen_type, data_type, instance_size, str(num_instance), str(num_keypoint)]) + ' ; [person'
+
+        if num_continuous_gen:
+            ctn = True
+            cur_instance = int(global_seq.split(';')[3].strip())
+            new_number = cur_instance + num_continuous_gen
+            if new_number > max_num_keypoint:
+                new_number = max_num_keypoint
+
+            # prompt type a
+            if global_seq.split(';')[5].find('[') == -1:
+                global_seq = global_seq.replace('[CLS]', '').replace('[SEP]', '')
+                objects = re.findall(re.compile(r'[\[](.*?)[]]', re.S), global_seq)
+                objects = ' '.join(['[ person' + x + ']' for x in objects])
+                seq_prompt = '; '.join([gen_type, data_type, instance_size, str(new_number), str(num_keypoint), objects])
+            # prompt type b
+            else:
+                global_seq = global_seq.replace('[CLS]', '').replace('[SEP]', '')
+                seq_list = global_seq.split(';')
+                seq_list[3] = str(new_number)
+                seq_prompt = ';'.join(seq_list)
+
+    elif gen_type == 'box' or gen_type == 'mask':
+        num_keypoint = 0
+        if data_type == 'object centric':
+            num_instance = 1
+        objects = ', '.join(object_name_inbox.strip().split(";"))
+        seq_prompt = '; '.join([gen_type, data_type, instance_size,
+                                str(num_instance), str(num_keypoint)]) + '; ' + objects
+        if len(object_name_inbox.split(';')) > num_instance:
+            return {
+                raw_sequence: gr.update(value=f"The umber of category names should be less than the number of instances, please try again :)", visible=True)
+            }
+
+        if num_continuous_gen:
+            cur_instance = int(global_seq.split(';')[3].strip())
+            new_number = cur_instance + num_continuous_gen
+            
+            if gen_type == 'mask':
+                if new_number > max_num_mask:
+                    new_number = max_num_mask
+            if gen_type == 'box':
+                if new_number > max_num_bbox:
+                    new_number = max_num_bbox
+
+            # prompt type a
+            if global_seq.split(';')[5].find('[') == -1:
+                global_seq = global_seq.replace('[CLS]', '').replace('[SEP]', '')
+                coords = re.findall(re.compile(r'[\[](.*?)[]]', re.S), global_seq)
+
+                objects = global_seq.split(';')[5].split(',')
+                objects = ' '.join(['[ ' + objects[i] + coords[i] + ']' for i in range(len(coords))])
+
+                seq_prompt = '; '.join([gen_type, data_type, instance_size, str(new_number), str(num_keypoint), objects])
+            # prompt type b
+            else:
+                global_seq = global_seq.replace('[CLS]', '').replace('[SEP]', '')
+                seq_list = global_seq.split(';')
+                seq_list[3] = str(new_number)
+                seq_prompt = ';'.join(seq_list)
+
+    # import ipdb;ipdb.set_trace()
+    print("input prompt: \n", seq_prompt)
+    with torch.no_grad():
+        sequence = gen_sequence(visorgpt_args, visorgpt_model, seq_prompt)
+        torch.cuda.empty_cache()
+
+    assert isinstance(sequence, list)
+
+    try:
+        cond_mask, cond_json = gen_cond_mask(sequence, ctn)
+        if gen_type == 'key point':
+            ori_sequence = cond_json[2]['sequences'][0][0] + '[SEP]'
+        elif gen_type == 'box':
+            ori_sequence = cond_json[0]['sequences'][0][0] + '[SEP]'
+        elif gen_type == 'mask':
+            ori_sequence = cond_json[1]['sequences'][0][0] + '[SEP]'        
+    except:
+        cond_mask, cond_json = gen_cond_mask(sequence, not ctn)    
+        if gen_type == 'key point':
+            ori_sequence = cond_json[2]['sequences'][0][0] + '[SEP]'
+        elif gen_type == 'box':
+            ori_sequence = cond_json[0]['sequences'][0][0] + '[SEP]'
+        elif gen_type == 'mask':
+            ori_sequence = cond_json[1]['sequences'][0][0] + '[SEP]'        
+
+    ret_img = Image.fromarray(cond_mask)
+
+
+    if not gen_type == 'mask':
+        return {
+            result_gallery: [ret_img],
+            raw_sequence: gr.update(value=ori_sequence, visible=True),
+            images_button: gr.update(visible=True),
+            text_container: cond_json,
+            sequence_container: ori_sequence
+        }
+    else:
+        return {
+            result_gallery: [ret_img],
+            raw_sequence: gr.update(value=ori_sequence, visible=True),
+            images_button: gr.update(visible=False),
+            text_container: cond_json,
+            sequence_container: ori_sequence
+        }
+
+def generate_images(gen_type, 
+                    num_samples, 
+                    ddim_steps, 
+                    object_prompt,
+                    seed,
+                    global_text,
+                    global_seq):
+
+    if gen_type == 'key point':
+
+        data = global_text[2]['keypoints']
+        idx = np.arange(len(data))
+        split_idx = list(np.array_split(idx, 1)[0])
+        for idx in tqdm(split_idx):
+            item = data[idx]
+            keypoint_list = []
+            for ins in item:
+                kv = list(ins.items())[0]
+                keypoint = (np.array(kv[1])).tolist()
+                keypoint_list.append(keypoint)
+
+        with torch.no_grad():
+            ret_img = control_infer(model=control_model,
+                                ddim_sampler=ddim_sampler,
+                                keypoint_list=keypoint_list,
+                                prompt=object_prompt.strip(),
+                                num_samples=num_samples,
+                                ddim_steps=ddim_steps,
+                                seed=seed)
+            torch.cuda.empty_cache()
+            
+    elif gen_type == 'box':
+
+        data = global_text[0]['bboxes']
+
+        with torch.no_grad():                
+            ret_img = gligen_infer(model=g_model, 
+                               autoencoder=g_autoencoder, 
+                               text_encoder=g_text_encoder, 
+                               diffusion=g_diffusion, 
+                               config=g_config,
+                               grounding_tokenizer_input=g_grounding_tokenizer_input,
+                               context_prompt=object_prompt.strip(),
+                               bbox_lists=data,
+                               ddim_steps=ddim_steps,
+                               batch_size=num_samples, 
+                               seed=seed)
+            torch.cuda.empty_cache()
+
+    if not gen_type == 'mask':    
+        return {
+            result_gallery: ret_img,
+            text_container: global_text,
+            sequence_container: global_seq
+        }
+    else:
+        return {
+            raw_sequence: "sequence to mask is not supported yet :)",
+            text_container: global_text,
+            sequence_container: global_seq
+        }
+
+
+def object_name_inbox_fn(gen_type):
+
+    if gen_type == 'key point':
+        return {
+            object_name_inbox: gr.update(visible=False),
+            data_type: gr.update(choices=['multiple instances']),
+            images_button: gr.update(value='Synthesize images using ControlNet'),
+            ddim_steps: gr.update(value=20),
+            object_prompt: gr.update(placeholder='in suit'),
+            num_instance: gr.update(visible=True, minimum=1, maximum=16, value=2, step=1),
+            sequence_container: None
+        }
+    elif gen_type == 'box':
+        return {
+            object_name_inbox: gr.update(visible=True, value='person; frisbee'),
+            data_type: gr.update(choices=['multiple instances', 'object centric']),
+            images_button: gr.update(value='Synthesize images using GLIGEN'),
+            ddim_steps: gr.update(value=50),
+            object_prompt: gr.update(placeholder='man and frisbee'),
+            num_instance: gr.update(visible=True, minimum=1, maximum=16, value=2, step=1),
+            sequence_container: None
+        }
+
+    elif gen_type == 'mask':
+        return {
+            object_name_inbox: gr.update(visible=True,
+                                         label="MS COCO categories to be generated (separated by semicolon)", value='bottle; cup'),
+            data_type: gr.update(choices=['multiple instances']),
+            images_button: gr.update(value='Synthesize images using GLIGEN'),
+            ddim_steps: gr.update(value=50),
+            object_prompt: gr.update(placeholder='bottle and cup'),
+            num_instance: gr.update(visible=True, minimum=1, maximum=8, value=2, step=1),
+            sequence_container: None
+        }
+
+
+def instance_type_change_fn(data_type):
+
+    if data_type == 'multiple instances':
+        return {
+            md_title: gr.update(visible=True),
+            num_continuous_gen: gr.update(visible=True),
+            continuous_btn: gr.update(visible=True),
+            object_name_inbox: gr.update(label="MS COCO categories to be generated (separated by semicolon)", value='person; frisbee'),
+            object_prompt: gr.update(placeholder='man and frisbee'),
+            num_instance: gr.update(visible=True, minimum=1, maximum=16, value=2, step=1),
+        }
+
+    elif data_type == 'object centric':
+        return {
+            md_title: gr.update(visible=False),
+            num_continuous_gen: gr.update(visible=False),
+            continuous_btn: gr.update(visible=False),
+            object_name_inbox: gr.update(label="ImageNet-1K categories to be generated", value='great white shark'),
+            object_prompt: gr.update(placeholder='great white shark'),
+            num_instance: gr.update(visible=False, value=1),
+        }
+
+block = gr.Blocks()
+with block:
+
+    text_container = gr.State()
+    sequence_container = gr.State()
+
+    gr.Markdown('<div align=center> <img src="file/visorgpt_title_all.jpg" width = "100%" height = "100%" /> </div>')
+
+    with gr.Row():
+        with gr.Column():
+
+            gr.Markdown("### Params to generate sequences")
+            gen_type = gr.inputs.Dropdown(choices=['key point', 'box', 'mask'], type='value', default='key point', label='Anotation Type')
+            data_type = gr.inputs.Dropdown(choices=['multiple instances'], type='value', default='multiple instances', label='Data Type')
+            instance_size = gr.inputs.Dropdown(choices=['small', 'medium', 'large'], type='value', default='large', label='Instance Size')
+            num_instance = gr.Slider(label="Number of instances per image", minimum=1, maximum=16, value=2, step=1)
+            object_name_inbox = gr.Textbox(label="MS COCO categories to be generated (separated by semicolon)", placeholder="person; frisbee", visible=False)
+            sequence_button = gr.Button(value="Customize sequential output")
+
+
+            md_title = gr.Markdown("### Continuous generation (Optional)")
+            num_continuous_gen = gr.Slider(label="Add instances to the current scene", minimum=1, maximum=16, value=1, step=1)
+
+            continuous_btn = gr.Button(value="Add instances to the current scene")
+
+            gr.Markdown("### Params to synthesize images")
+            object_prompt = gr.Textbox(label="Context Prompt", placeholder="in suit", visible=True)  
+            num_samples = gr.Slider(label="Batch Size", minimum=1, maximum=36, value=1, step=1)                
+            ddim_steps = gr.Slider(label="Steps", minimum=1, maximum=100, value=20, step=1)
+            seed = gr.Slider(label="Seed", minimum=-1, maximum=2147483647, step=1, randomize=True)              
+            images_button = gr.Button(value="Synthesize images using ControlNet", visible=False)
+
+
+        with gr.Column():
+            raw_sequence = gr.Textbox(label="Raw Sequence", visible=False)
+            result_gallery = gr.Gallery(label='Output', show_label=False, elem_id="gallery").style(grid=2, height='auto', preview=True)                  
+            
+    gen_type.change(object_name_inbox_fn, inputs=[gen_type],
+                    outputs=[object_name_inbox, data_type, images_button, ddim_steps, object_prompt, num_instance, sequence_container])
+
+    data_type.change(instance_type_change_fn, inputs=[data_type],
+                     outputs=[md_title, num_continuous_gen, continuous_btn, object_name_inbox, object_prompt, num_instance])
+
+
+    ips = [gen_type, data_type, instance_size, num_instance, object_name_inbox]
+    sequence_button.click(fn=generate_sequence, inputs=ips, outputs=[result_gallery, raw_sequence, images_button, text_container, sequence_container])
+
+    ips = [gen_type, data_type, instance_size, num_instance, object_name_inbox, num_continuous_gen, sequence_container]
+    continuous_btn.click(fn=add_contents, inputs=ips, outputs=[result_gallery, raw_sequence, images_button, text_container, sequence_container])
+
+    ips = [gen_type, num_samples, ddim_steps, object_prompt, seed, text_container, sequence_container]
+    images_button.click(fn=generate_images, inputs=ips, outputs=[result_gallery, raw_sequence, text_container, sequence_container])
+
+block.launch(server_name='0.0.0.0', server_port=10086, debug=False, share=False)
+

demo/ckpts/controlnet/cldm_v15.yaml

@@ -0,0 +1,79 @@
+model:
+  target: visor_controlnet.cldm.cldm.ControlLDM
+  params:
+    linear_start: 0.00085
+    linear_end: 0.0120
+    num_timesteps_cond: 1
+    log_every_t: 200
+    timesteps: 1000
+    first_stage_key: "jpg"
+    cond_stage_key: "txt"
+    control_key: "hint"
+    image_size: 64
+    channels: 4
+    cond_stage_trainable: false
+    conditioning_key: crossattn
+    monitor: val/loss_simple_ema
+    scale_factor: 0.18215
+    use_ema: False
+    only_mid_control: False
+
+    control_stage_config:
+      target: visor_controlnet.cldm.cldm.ControlNet
+      params:
+        image_size: 32 # unused
+        in_channels: 4
+        hint_channels: 3
+        model_channels: 320
+        attention_resolutions: [ 4, 2, 1 ]
+        num_res_blocks: 2
+        channel_mult: [ 1, 2, 4, 4 ]
+        num_heads: 8
+        use_spatial_transformer: True
+        transformer_depth: 1
+        context_dim: 768
+        use_checkpoint: True
+        legacy: False
+
+    unet_config:
+      target: visor_controlnet.cldm.cldm.ControlledUnetModel
+      params:
+        image_size: 32 # unused
+        in_channels: 4
+        out_channels: 4
+        model_channels: 320
+        attention_resolutions: [ 4, 2, 1 ]
+        num_res_blocks: 2
+        channel_mult: [ 1, 2, 4, 4 ]
+        num_heads: 8
+        use_spatial_transformer: True
+        transformer_depth: 1
+        context_dim: 768
+        use_checkpoint: True
+        legacy: False
+
+    first_stage_config:
+      target: visor_controlnet.ldm.models.autoencoder.AutoencoderKL
+      params:
+        embed_dim: 4
+        monitor: val/rec_loss
+        ddconfig:
+          double_z: true
+          z_channels: 4
+          resolution: 256
+          in_channels: 3
+          out_ch: 3
+          ch: 128
+          ch_mult:
+          - 1
+          - 2
+          - 4
+          - 4
+          num_res_blocks: 2
+          attn_resolutions: []
+          dropout: 0.0
+        lossconfig:
+          target: torch.nn.Identity
+
+    cond_stage_config:
+      target: visor_controlnet.ldm.modules.encoders.modules.FrozenCLIPEmbedder

demo/ckpts/controlnet/control_v11p_sd15_openpose.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:db97becd92cd19aff71352a60e93c2508decba3dee64f01f686727b9b406a9dd
+size 1445235707

demo/ckpts/controlnet/v1-5-pruned-emaonly.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ce0161689b3853acaa03779ec93eafe75a02f4ced659bee03f50797806fa2fa
+size 4265146304

demo/ckpts/gligen/diffusion_pytorch_model_box.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f5f3d2d5ec6e01c7ad7ca811a39904db675d1c5fccfeca9d34d63e4bf65ccd7b
+size 6775067861

demo/ckpts/visorgpt/visorgpt_dagger_ta_tb.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ad8c442caf1ec58accc97dbc5b0636e4398a9853cf6e6475f5be01f087da245
+size 219003175

requirements.txt

@@ -0,0 +1,160 @@
+absl-py==1.4.0
+addict==2.4.0
+aiofiles==23.1.0
+aiohttp==3.8.4
+aiosignal==1.3.1
+altair==4.2.2
+antlr4-python3-runtime==4.9.3
+anyio==3.6.2
+asttokens==2.2.1
+async-timeout==4.0.2
+attrs==22.2.0
+backcall==0.2.0
+basicsr==1.4.2
+blinker==1.5
+brotlipy==0.7.0
+cachetools==5.3.0
+certifi @ file:///croot/certifi_1671487769961/work/certifi
+cffi @ file:///tmp/abs_98z5h56wf8/croots/recipe/cffi_1659598650955/work
+charset-normalizer @ file:///tmp/build/80754af9/charset-normalizer_1630003229654/work
+click==8.1.3
+clip==0.2.0
+contourpy==1.0.7
+# Editable install with no version control (controlnet==1.0)
+-e /home/cvi_demo/PPSM/demo/ControlNet
+coqpit==0.0.17
+cryptography @ file:///croot/cryptography_1673298753778/work
+cycler==0.11.0
+decorator==5.1.1
+einops==0.6.0
+elasticsearch==1.9.0
+entrypoints==0.4
+executing==1.2.0
+fastapi==0.95.0
+ffmpy==0.3.0
+filelock==3.11.0
+flit-core @ file:///opt/conda/conda-bld/flit-core_1644941570762/work/source/flit_core
+fonttools==4.39.3
+frozenlist==1.3.3
+fsspec==2023.4.0
+ftfy==6.1.1
+future==0.18.3
+# Editable install with no version control (gligen==1.0)
+-e /home/cvi_demo/PPSM/demo/GLIGEN
+google-auth==2.17.2
+google-auth-oauthlib==1.0.0
+gradio==3.25.0
+gradio-client==0.0.10
+grpcio==1.51.3
+h11==0.14.0
+httpcore==0.17.0
+httpx==0.24.0
+huggingface-hub==0.13.4
+idna @ file:///croot/idna_1666125576474/work
+imageio==2.27.0
+importlib-metadata==6.1.0
+importlib-resources==5.12.0
+ipdb==0.13.13
+ipython==8.11.0
+iso8601==1.1.0
+jedi==0.18.2
+Jinja2==3.1.2
+jsonschema==4.17.3
+kiwisolver==1.4.4
+kornia==0.6.10
+lazy-loader==0.2
+lightning-utilities==0.8.0
+linkify-it-py==2.0.0
+lmdb==1.4.0
+Markdown==3.4.3
+markdown-it-py==2.2.0
+MarkupSafe==2.1.2
+matplotlib==3.7.1
+matplotlib-inline==0.1.6
+mdit-py-plugins==0.3.3
+mdurl==0.1.2
+mkl-fft==1.3.1
+mkl-random @ file:///tmp/build/80754af9/mkl_random_1626186064646/work
+mkl-service==2.4.0
+multidict==6.0.4
+networkx==3.0
+numpy @ file:///tmp/abs_653_j00fmm/croots/recipe/numpy_and_numpy_base_1659432701727/work
+oauthlib==3.2.2
+omegaconf==2.3.0
+open-clip-torch==2.16.0
+opencv-python==4.7.0.72
+orjson==3.8.10
+packaging==23.0
+pandas==2.0.0
+parso==0.8.3
+pexpect==4.8.0
+pickleshare==0.7.5
+Pillow==9.3.0
+pkgutil-resolve-name==1.3.10
+prompt-toolkit==3.0.38
+protobuf==3.19.6
+psutil==5.9.4
+ptyprocess==0.7.0
+pure-eval==0.2.2
+pyasn1==0.4.8
+pyasn1-modules==0.2.8
+pycparser @ file:///tmp/build/80754af9/pycparser_1636541352034/work
+pydantic==1.10.7
+pyDeprecate==0.3.2
+pydub==0.25.1
+Pygments==2.14.0
+PyJWT==2.6.0
+pyOpenSSL @ file:///opt/conda/conda-bld/pyopenssl_1643788558760/work
+pyparsing==3.0.9
+pyrsistent==0.19.3
+PySocks @ file:///tmp/build/80754af9/pysocks_1605305779399/work
+python-dateutil==2.8.2
+python-multipart==0.0.6
+pytorch-lightning==1.6.5
+pytz==2023.3
+PyWavelets==1.4.1
+PyYAML==6.0
+regex==2023.3.23
+requests @ file:///opt/conda/conda-bld/requests_1657734628632/work
+requests-oauthlib==1.3.1
+rsa==4.9
+scikit-image==0.20.0
+scipy==1.9.1
+semantic-version==2.10.0
+sentencepiece==0.1.97
+share==1.0.4
+six @ file:///tmp/build/80754af9/six_1644875935023/work
+sniffio==1.3.0
+soundfile==0.12.1
+stack-data==0.6.2
+starlette==0.26.1
+tb-nightly==2.13.0a20230410
+tensorboard==2.12.0
+tensorboard-data-server==0.7.0
+tensorboard-plugin-wit==1.8.1
+tensorboardX==2.6
+tifffile==2023.3.21
+timm==0.6.13
+tokenizers==0.13.2
+tomli==2.0.1
+toolz==0.12.0
+torch==1.12.1
+torchmetrics==0.11.4
+torchvision==0.13.1
+tqdm==4.65.0
+traitlets==5.9.0
+transformers==4.27.4
+typing-extensions @ file:///croot/typing_extensions_1669924550328/work
+tzdata==2023.3
+uc-micro-py==1.0.1
+urllib3 @ file:///croot/urllib3_1673575502006/work
+uvicorn==0.21.1
+wcwidth==0.2.6
+websockets==11.0.1
+Werkzeug==2.2.3
+yapf==0.32.0
+yarl==1.8.2
+zipp==3.15.0
+visor_controlnet
+visor-gligen==1.1
+visor-controlnet==1.1

train/README.md

@@ -0,0 +1 @@
+The code is highly based on [TencentPretrain](https://github.com/Tencent/TencentPretrain).

train/__init__.py

@@ -0,0 +1 @@
+from .scripts import *

train/beginning.txt

@@ -0,0 +1 @@
+key point; Multiple instances; 5; 14; medium;

train/datasets/test_data/book_review/dev.tsv

@@ -0,0 +1,201 @@
+label	text_a
+1	洋洋洒洒五百多页，基本全部是伍迪·艾伦在说，内容几乎没有纰漏，不过重复的地方也不少。
+1	写类型片编剧的宝贝，虽然偏向商业化，但是也能学到很多对剧本节奏的建议
+1	真会讲故事啊
+1	一知半解的德棍只喜欢德三，真正愿意探寻历史的德粉，也许更偏好普鲁士
+0	弃
+0	很生气，一晚上看完，只有生气。太矫情了
+1	这个标题真是太贴切了，真的是罪，真的是美。
+1	想起导师改我文章的时候就像"写作风格"那章写的那样改的，看着眼熟。还是一样啊，技术可以通过反复模仿习得，但是角度却不能随着数量的叠加而变得更加独到，就像年少时的学霸和学神，以及好的导演让人心满意足的标上四星，而有灵性的让人一个冲动就满星了。
+1	拍电影极生气时候导拍断过手，踢断过腿，真是个暴烈的人呀。
+0	两星到三星之间的作品
+1	在瞎子的世界，谁有一只眼睛谁就是国王
+1	你这死尸的囚徒!（还是囚徒的死尸来着?）
+1	清平定准葛尔标志着游牧帝国的结束
+0	没有才调，看在材料份上加一星。
+0	我对这个作者没爱，了了
+1	比 《认识电影》深奥。。。。
+1	历史书做成这样真是太赞了！
+1	电影更值得一看
+0	我只想说 我为了跟上潮流==
+1	英文名称与中文译名都不错，引人入胜的小说。电视剧也很棒。
+1	我的帝王生涯
+0	这个推理特别牵强 从一开始就能猜到最后的大boss必然是他身边的几个同事之一 看起来最傻的那个最可疑 游戏线写的还不错 可生活线太糟了 埋伏笔埋得太刻意 称不上是一本好的悬疑
+1	伍迪艾伦把工作和私生活分的很开，即使是被前妻起诉，外界对他议论纷纷的时候，他还是保持工作的节奏，把官司交给律师，不像国内的那些跳梁小丑，消费自己的生活，只为一点关注度。
+0	希望看到的是活生生的人，可惜只看到假大空的神
+0	废话太多
+0	啥玩意，情色系的啊。故事一般。看的困。
+1	文人骨子里的东西~其实我读起来有点像文人版的麦田里的守望者~
+1	普通法等。翻译假装要扣一星。电子版反倒没有删节。
+0	你是猴子请来的逗逼吗。
+0	人生读过最狗血的书之一  除了对了解穆斯林信仰风俗有所帮助之外都是狗血
+1	读胡金铨在韩国拍摄空山灵雨一段，越发觉得空有一番热忱是什么都做不成的，要与环境做各种妥协、交换，也要有自身的主心骨，切勿随波逐流，乱了方寸。
+1	什么叫震撼人心？！
+1	照片珍贵。
+1	偶的启蒙书之一~
+1	看片量差远了，回头再回锅
+0	两章果断弃！
+1	从农村到城市，中国的城乡进程讲述的很详细，历史脉络清晰。
+0	跟看我高中同学的日记本差不多。
+0	这种硬科幻，真是受不了。
+1	作为资深影迷，这本书必读
+1	现实与荒诞，耶稣与撒旦，奇诡的想象恣意横生、酣畅淋漓。趁热打铁，可以把剧看起来了，谢谢木木老师的码~~
+0	小白，后面没怎么虐楠竹。
+0	一句话我就不想看了：诸葛亮在刘表身边，他却不能发现，这个人好蠢。。。什么人才是二十一世纪最重要的。历史这种解读，真是醉了。还有那么高的分，可见一斑。
+1	这书有毒！
+0	为了曲折和煽情而造作,悲剧得不可思议
+1	终于在这个被工作和学习双重折磨的阶段，读完了岳南先生的这部大作。。虽然只有120万字，但是作者耗费的心力应该有一亿两千万字。当读到穆旦在深夜冒着严寒走几个小时，只为了去给因文革而几个月没见的妻子送去几块糖，这样的感动让人无法言喻。这本书五星推荐！
+1	受益匪浅
+0	帮人查点东西又翻出来了。错讹哪些属于有意哪些归于无心也不用多想。不过最近居然听闻有人认为讲古代史的文献须核对，讲现当代历史的大段引文则“意思对就行”不必强求，连出处都可以不标注。若不是故意甩出双重标准，那就是真心无知且不怕惹人耻笑。所谓“意思对”简直是自黑。出版规范先不讨论，近现代文化史艺术史扯不清楚，原因真是丰富多彩。
+1	虽为一家之言，不过很有启发
+1	(⊙o⊙)。。卧。。槽。。
+1	果不其然地掉泪，人之初，性自由。忽然觉得很对。
+0	精与屎
+1	电影就是这么神奇，简直不可思议，一寸移动，一个角度改变，一个连接，哪怕只多停留1秒，观众就能感知到巨大的情感震撼。别问为什么，要问问心理学家。此书可以算拉片总结，部分镜头在大量阅片和经验中已经成为了意识惯性。
+0	希望有一天自己可以孤独的去旅行吧
+1	只看了篇简单的书评介绍就被迷住了，这本书似乎能解决我的许多疑惑，就像当年遇到弗雷泽《金枝》的那种豁然开朗，所以，���一定要看看。读到“二十，放马天山雪中草”为止，等资源。
+1	人类绘制地图的历史也像人类理解自然世界的历史一样，充满着曲折，我们的视野被技术、能力、宗教、政治、经济等外部因素不断影响，而没一副地图也代表了一个时代和一种观点，说明了我们是如何一步步走来的。震撼人心的一本书，实在太棒！
+0	网上找的，看到三分之一还在罗里吧嗦的介绍人物性格，看不下去了弃文
+0	罗里吧嗦
+1	喜欢这种感觉的书~
+1	好的通史绝不是泛泛而论，而是有自己可称作主心骨的意见。钱穆此书作于全民抗战时，国族危急存亡之秋自然有许多人检讨乃至彻底否定过去数千年历史。钱穆则认为以一时一地的得失一边倒地臧否过去乃是失智。譬如他认为中国古代（除清朝外）之无民主代议制是必然，因为该制度根本就不必要（参页三九九）。当然，钱穆也并不避讳历代政治之失误。有许多人认为钱穆亲中贬西，我觉得要从其讨论的背景才能理解他的立场。
+0	桐华你是有多恨姓孟的
+0	我要这天，再遮不住我眼；要这地，再埋不了我心。要这众生，都明白我意，要那诸佛，都烟消云散！ 我可以忘了我自己，可是，我忘不了东海水，忘不了花果山，忘不了西天路，忘不了路上的人。
+0	写得太差了！絮絮叨叨完全不像她的文字风格，只有为虐而虐的传统保持下来了，完全看不下去。
+0	这次东野先生尝试了关于脑死亡与器官移植的话题，在一些小的片段上也延续了他作为一个推理小说家善于营造气氛的特点，然而这本书的故事性实在是太弱，书中的人物关系也过于浅尝辄止，以至于有很大的篇幅让人感觉是在注水，最后虽然给了一个皆大欢喜的结局，却又显得很刻意。
+0	“二十岁就知道的事，却花了一辈子来证实。爱情，正如死亡，不由分说。”萨冈的短篇太弱了
+1	对胡金铨有一个详细的访谈，也有一些八卦。
+1	政治追求与爱恨情仇…
+1	希望多年后的我能认真地重读这本书
+1	意识流日记。搞艺术的人我真的从来不懂，但文笔和封面一样美……
+1	有收获。有励到我的志
+0	超不喜欢结局
+1	在我读过的少得可怜的诺奖作品中，这是最喜欢的一本。细节之处很见功力，描写优美又不显拖沓。并非教徒的人显然可以把“你往何处去”的主语换成自己心中的某种力量或准则，一样有震撼人心的美。“毒杀你的人民吧，可别再跳舞了”。这句简直是今年阅读的年度之句。显克微支大大这里有一只你的脑残粉！！！
+1	很踏实和基础，用书的形式体现影像变化有点吃力，但作者已经描述得很不错。对于构建剪辑学的整体脉络有帮助。
+1	咦居然看过。但是只记得不要和胖友吃饭因为胖会传染了😂
+0	感觉作者开创了一个新的文学流派：中国历史轻小说……为了捧偶像传主的臭脚，竟不惜篡改史料原文、以论带史甚至主观臆造，读之瞠目结舌。后记更是彰显了日本史学界的无知，竟有说雍正是明朝年号，我还说德川家康是日本天皇哩……
+0	傻书。注解比原文还多，看着累，到后面就跳过不看。光看文，一个字。
+0	不知道是翻译的问题还是原来的文字就是这么样，不喜欢。故事很《读者》之类的。
+1	理论系列，比较深，需要常读。。。
+0	实在不是我喜欢的文体
+0	我当时准备买这本书时，看豆瓣评分9.5，于是就买了这本书.最近看完才发现，完全不值得这么高的评分.翻译还算凑合，一些名字，图片的和正文的不符合。内容不是很好，就是讲了英格兰的国王和一些伟人的算是历史的故事，算不上英格兰简史，我看可以称之为英格兰著名人物史，一些个人认为比较重要的事件都没有谈到，或涉及很少.如果想打发时间，就当读故事看看得了.没啥可读性.就是书的纸张、印刷挺不错的.以上为个人观点.
+0	多么苍白无力的剧情,脸谱化的主角,幼齿的语言,我怎么会看了这么本书,killing time的资格都没有。。
+0	只看了其中的《趁生命气息逗留》一篇。按照这么长时间以来养成的读书传统，照理说对大师的作品要保持相当的尊敬的。即使不欣赏，也只是把这评论放在心里，甚至在看到大多数人对书的的评论都相当高的时候，会偷偷想是不是自己素养没达到，所以欣赏不了。 好吧，我承认《趁生命气息逗留》读后感觉一般，打两星。不过这不代表这书不好或是对大师的不尊敬，仅用于积累喜好数据使豆瓣给我更好的推荐适合个人口味的书之用。
+0	能读完也是蛮佩服自己的……Twentine最烂的小说
+1	誠之先生一生所讀史治學心得皆囊括於中。
+0	读完以后���第一个反应是：额(⊙o⊙)…就这样？现在出版社为了卖书真是什么都敢写啊，让整个欧洲怦然心动的小说？！如果真是这样，欧洲人民的阅读品味也太……哎，像这种没有内涵，阅读快感又不足的作品真是少读为妙。
+0	弃了
+0	看不下去，因为作者是文艺教授，所以书写的好学究的，而且也是一个老掉牙的故事，书中总说女主很慌恐，有稳定的职位，完全可以另寻他人，非搞得要死要活，不过也佩服作者，这么简单的故事可以写15万字。
+0	格局太小，偏向于情感，不是特别易读。
+1	几个典型的剪辑分享
+1	没达到我对切的要求，嘿嘿。
+1	上课看 看到p61 哭
+1	特别像经济学中的一章，新兴经济学。第一次知道防策略性的重要，总体来说，对每个人都好的决定，却不一定稳定且可实现。全局观还是有一定限制性的，全局中的个体都是追求个人利益最大化的。
+1	冷热交替的阅读感
+0	12岁看的……18岁的时候才有些理解了那种感觉……但仍然缺乏对这种文的感受器……摊手……
+0	别。开头儿看得到结尾。主角比读者蠢，搞咩啊。。。
+0	肤浅做作，读过一遍，够了。比源泉差太多了。
+0	淡淡的忧伤，忧伤到蛋疼。
+0	真失望，毫无新奇特色
+1	先前读英译本尚有若干细节读得迷糊，在这本里得到满足~~没有炫丽的文采和技巧，没有玄妙的结构，就是踏实的叙述~~但是，波拉尼奥是讲故事的天才，篇篇讲得暗流涌动，篇篇喜欢！比较奇怪的是，同样的赵德明的翻译，《荒野侦探》和《2666》我读了十页就读不下去，这本尽是短句，读起来十分畅快，而且据说从西语直译，和英译本的调子竟然也八九不离十，刮目相看~~~《荒》和《2666》的中译改天买来再试着读读看~~
+0	不要误会，我不是针对大冰的这一本书，我是说大冰的所有书，都是垃圾。
+1	好书，改革的这几十年
+1	经典之作！犀利的视角，绵里藏针的笔触
+0	不知道好在何处，难道就是因为是创办了PayPal?
+1	人道主义和国家利益的博弈。“忽视历史的人更容易成为历史的受害者”
+1	1.好多人没听过。  2.写的不错。
+0	看了之后感觉失望
+1	很奇怪地，读书时，眼前像看书中所道之画面，耳畔如作者在娓娓讲述。很久没读到这么好的书了。
+1	看来看去，最喜欢看的还是港片。嗰书几好睇
+0	还挺红的小言，真谈不上好看
+1	香蕉鱼家族
+1	通过法拉奇的描写，看到了不一样的好莱坞明星们的生活
+1	重复博弈开始看不懂。看懂的部分对思维的启发和拓展都很大。
+0	这本书太慢热，我实在坚持不住。
+0	性价比低 排版用纸少美学 总之不值这个价
+0	火车上读的，很水
+1	没找着英文pdf又不想花钱买（……），于是看了中文pdf。好像少了最后一章，不过这本书看到后边让我觉得非常疲劳非常千篇一律，就也不是很care少了的那一章了。。。
+1	里面说到的一些金融模型什么看不懂。。太专业了。。不过这本书还是蛮有意思的～看着看着会想到乌合之众里面讲的，群体的智力有时候不及个人啊，即使是那些华尔街的天才们。都是被钱障目。
+0	不止针对本册书，针对全文的评论 开头我真切的怀疑女主真的是国安局上将，为衬托男主的腹黑各种低智。文章宠得时候又太腻太甜，许多情节都凑在一起重复发生，如果穿插起来会是好文。 对于人物的刻画并不具体，大都是虚无缥缈的气质，强大的气场，对于人物的描写太单薄，仅仅突出人物的某一突出特点夸饰却不用具体事件表现，甚至有偷换概念嫌疑 里面作者传达的主观思想借配角和主角的心理描写亦或旁白表达太明显，人为的定义哪个人的对错善恶好坏，而不是给人以思考空间，盲目推崇主角，跟主角作对的都没有好下场，跟主角站在一边的都有好结局，弃“暗”投“明”的也最终获得幸福。对于人物心理的刻画是硬伤，本来以前所作所为都是装的就很牵强(三分真七分假才不会被对手察觉)所思所想都被推翻的小说大概称不上一波三折
+1	越来越精彩了，人物刻画相比前两部好了许多，作者对历史与文学的掌握和运用相当牛，添彩不少！期待大结局
+0	胡乱引用，文不对题，不知所谓，比秦风老照片系列差远了。
+0	这是拿推理小说当爱情小说写，其实绝大多数谋杀都是因为钱，为情极少，作者肯定是个腐女，把男性之间的感情写那么肉麻，完全是一种迎合而已。
+1	2 每次读这种电影类书籍的时候才会发现自己的观影量有多么的匮乏，还需慢慢积累。
+1	黑得漂亮
+0	一句话：苏联上层精英背叛了马列正统思想，倒向了资本主义，因此苏联解体了，社会主义制度崩溃了。学过社会科学方法论的都不应轻易接受这种解释，比如：为什么戈尔巴乔夫的渐进转型和改革失败？苏联哪些上层转变了态度，为什么会转变态度？又在现实中有什么影响？普通民众没有影响吗？书中逻辑矛盾和问题大面积存在。
+1	无论从装帧，翻译还是书本身都值得给足五颗星。那条书评说得有道理，从某种意义上说，书里的文字有包豪斯的共通理念。
+1	我的笔为此而从某个时候开始跑起来，向着他跑去，它知道他不久就要到来。
+1	确实没有多少国家能像俾斯麦的普鲁士一般，光辉灿烂地走上毁灭。而且哈夫纳的笔尖，如同跳跃的音符，谱写出一曲悲壮的普鲁士覆亡的篇章。来时何其壮哉（高度理性，纯军事化，三无政策的国度），去时柔风细雨（威廉二世乐得做德意志皇帝，而不愿提及普鲁士国王，也逐渐让普鲁士融入于大德意志民族之内）
+1	文笔细腻 内容考究
+1	可以省去不少本因被浪费的时候
+1	赞理性和严谨。也赞死也不愿考虑政治因素的执着。
+0	很讨厌啊。
+0	文笔太弱了
+0	文不对题，读不下去。
+0	对于我来说，一本书，第三类的配角的性格不能乱改，要改必须得给个理由。比如，一个情节里面，路人的性质就是路人，他没其他风格。这书里面一个第三类配角的性格，它换了两次，我受不了！
+0	內容空洞無病呻吟，與文化積累較深的文人寫的行記無法比較，一小時就看完的書，除了裝幀精美，實在無可贊之處，似乎是一個初中生的日記般
+1	亚马逊11RMB 朱伟说昆德拉是三流作家是不是有点过分呢？
+0	没有南极中的细节展现好，而且风格过于冷峻了。。没有个人特色。。读来乏味
+1	多一颗星是因为这是一百年前的认识，特别是附录1的价值。
+1	终于看完这本书了。书里描写的是那些被生活折磨着，爱情已经死去，每天只是鸡零狗碎的重复，时刻处在崩溃边缘的人。我觉得还得多看几遍，是因为我现在读起来还很吃力。
+1	2017读过的top3之一，从宇宙万物混沌虚无到现在这个时点，所需的每一次进化都是一个偶然事件，读后会觉得能生存在此时此地是多么有幸。全书的结构清晰，内容详细，很适合对细节十分考究的读者，虽然此书价格小贵哈哈，但读后绝对一本满足
+0	只读了开头，翻译的太差了……
+1	超级霹雳无敌金刚五星。看电视剧都看不懂，我说为啥我总是觉得我懂得多，原来小说里有画外音有心理描写有评论。我真是一个愚昧的人啊。。。
+1	罗杰斯到底是有多爱中国
+0	实在看不下去不是我口味
+1	大赞！
+0	知青奇幻式的片子，书呆子棋王在逆境中爆发无尽的魅力，小说最后不了了之。电影则完全变成另一种模式，尤其是炮二进三，马四平八的大棋盘对弈，气势极佳。电影远比小说好，小说毫无所谓“多层次性”，糟糕得很，吹捧而已。
+1	没有完美的公司，终有科学的管理。不愧为复旦新闻系科班出身，功底扎实。
+0	唯一能确定的是，卡佛很极其熟悉酗酒中人的状态，但这，连带整本书，也算不得一丝半点真正的意义
+1	读完了，蛮有收获的。初级入门的工具书吧~
+0	骗钱的吧
+1	不要用眼睛去看好莱坞，而要用欲望、嫉妒、想象去看它。
+0	写的太白痴了。。。。
+0	小天真
+1	太好看！
+0	莫非法国人的法语水平都堕落了？
+1	我读的是中国电影出版社2000年的版本
+0	《偏执狂》 女主照顾瞎眼男主成功上位。。。
+0	超级失望，完全是个拼凑卖纸的玩意。
+0	电视剧太拖沓了就花了两个小时找了电子版来看，如果这就是亦舒的代表作那她写得也并不好啊。套路太简单了，也太模式化了。性格转变都很突兀。不过呢，比电视剧版子君还是好很多啊………………难怪大家看到电视剧版子君要气死吧。。。
+0	如果说Lonely Planet是旅行者的圣经，这本一定是砸牌子的。 英文原文应该还不错，但半吊子的翻译使得它只剩参考价值了，没错，仅供参考。菲律宾那本倒是很好用，至于日本，看书还不如自己上网站查。
+0	N年前看过，勉强感觉还不错，现在知道是抄袭呵呵
+0	不说内容，只说制作。当当活动46折买的，印刷品质粗恶到令人发指。书口都是花的。印刷厂印这书居然用了五种质地各种差各种不一样的纸。油墨味极大极刺鼻。封面设计很好，但是制作实现时各种假，看照片还以为是布脊，其实是劣质铜版纸塑料膜从天糊到地。劣等商品差差差。
+0	本来我是多热爱运动系少女的啊……看了电视剧再去看书。觉得电视剧真是升华了。小说里的各种白痴逻辑我居然看完了这也是醉了��😱😱😱
+1	全新的知识
+0	没有打动我
+1	很好的教科书。
+0	读了一百多页表示看不到支持读下去的动力吸引力，三星打得很宽容了，想想对这本书的预期这么高，这么个名声，要减一颗
+1	真的很不错，里面很多案例都值得学习，而且明显读了之后感觉自己的思维方式有了一定的改变
+1	关于对孤独的解读你如此清澈如此玩世不恭的诚恳道来
+0	这本书是娘们看的玩意儿
+0	就不加友情分了…
+1	或轻松或犀利的文笔，介绍的很多是年代久远的片子，偶尔翻出来看看，也是很好的。
+1	看完几乎所有是枝裕和的作品，再看这本书还是有所获得的，比如很多电影的分镜，比如奇迹本来竟是boy meets girl的故事，还好改成了现在这样。其他的部分，还是以周围人的评价和看法居多，是枝裕和内心的东西还是偏少，访谈访的也不深，不过树木希林那段还是蛮让人深思的。
+0	夸大其辞
+0	读了一多半。不喜欢。也没完全读懂。2014年2月读。
+1	才知道，原来竺家荣译的是个“洁本”！！！！那这个版本是否完整？
+0	太长了看不完也看不懂
+1	讲述了分离联盟的存在对国家兴衰的影响
+0	盛名难副 浪费时间 矛盾奖原来是个施粥的
+1	还没看完。。。看起来满累的。。。
+0	为什吗我看的都是这么殴的书！！！
+0	实在读不下去~~
+1	那是05年的寒冬，在大连图书馆馆藏部看的，当时看的真吃力。10年5月初第二遍开读，10年6月初读完。
+1	长亭外，古道边，芳草碧连天；晚风佛柳笛声残，夕阳山外山。。。
+1	毛蟹推荐的
+0	写个男主是有多可怜！！！女主是有多蠢！完全就是来谋杀男主的哈哈哈哈哈！！！！
+1	英文名<How China Became Capitalist?>更适合本书主题。全书讨论了诸如双轨结构、边缘革命、地方竞争等话题，梳理了共和国建国六十年来的经济政治变迁，有点像基辛格《论中国》的经济学版。
+0	果然摘抄不可信啊！有些书做摘抄，一段一段拿来都很好看，合起来就不见得了……其实看题目就知道没什么趣味了吧……orz
+1	第一次看这类书籍，还是很有收获的，第二三部只是简单翻了翻没有细看了，第二部更像练习册的答案，可以自己看完片子后对照书上写的，自己踩点是否正确。中文版翻译貌似很不好？有空再瞅瞅原版吧！
+1	人类学结构下的边疆历史，强弱相生的观点的确有理且有趣，对中原北疆及东北的三分式解析，以及对掠夺式和二分法的政治策略解析也站得住脚。而且不同于国内学界对中原国家的非理性认同和隐约偏见及马列史观对历史进步性的刻意把握，采取对汉人朝廷脸谱化，转而对漠北及东北人物的详细刻画，五星好书。
+1	看完标记。中间四星，第一本和结尾五星。
+0	路内完蛋草了
+0	TND，谁打了这么高的分，浪费感情浪费时间。弃！
+1	之前在淡水的哪个小书店里站着看完台版了 最近小猴又送我一本儿陆版  新经典的礼物 开心 值得再读一遍
+0	哼哼 哼哼
+0	这逼装到了天际，男主是江西婺源的，哈哈哈，容我笑一阵…
+0	给了2星，因为貌似我还没给哪本书1星。修正，曾经给《秘密》这种骗人的书1星。
+1	第一遍硬啃，第二遍慢慢开始顺畅了，还是得花笨功夫。
+1	年度最佳随笔集。杨老师已然大师风范。即使是风格随意不拘一格的随笔文，杨依然可以站在世界史的视野上结合中国近代以来的具体情况，讲述民族主义在中国的形成，选择与演变。论述有趣，史料选择恰到好处。值得一读。
+1	还不错，但最后有些不喜欢~~

train/datasets/test_data/book_review/test.tsv

@@ -0,0 +1,201 @@
+label	text_a
+0	我惊了，这些评论的人真的都看了这书吗？还是都是托.....
+0	男主好渣！看的气死我了！
+0	大概初中及初中以下水平读者会把这奉为神作吧。今何在构建作品里抹不掉的中二气。
+0	编辑肯定约稿时候反复提及以“艳遇”为中心了。然后作孽般的拼凑成这么一本破书。都神马水平啊这。
+0	我是读不下去了……
+0	严重过誉，斯蒂芬·茨威格这历史观以及叙事的方式和内容，就好像在看现代人拍的古装剧。最无法认同他将历史进程归咎于某些人的一念之差
+0	太不真实
+0	手贱的代价。神马傻逼玩意儿
+0	算......黑历史吧......= =
+0	一向的风格。懒得说了。
+0	一开始还挺好看的，可是后面就烂尾了…不停地分手在一起分手在一起……还穿越…唉
+0	不懂为什么分这么高 我觉得这书的内容真的很一般
+0	如果不是宣传吹嘘得太夸张，和预想相差甚远的话，或许我给的是三星。失望是最可怕的。
+0	不多说了。
+0	看完有一种杀了作者的冲动。这年头是什么人都可以出书了么，三联你要不要这么砸自己的牌子啊！
+0	翻译之差，无出其右
+0	当初看的网络连载版，说真的这文到后面越来越崩坏，谁能告诉我女主这么穿越的意义究竟何在？虽然出了大事故，但原来的生活很美好啊。如果走穿后的那一条线也就算了，可以理解为想让男女主早点遇见，可问题是后面又回去了是要闹哪样？感觉此作者的作品没有以前的好看了
+0	yy得太过分了，文笔普通，还披着软文伪网游的皮……………………又一个得分很高实际很烂的瞎文= =。
+0	浓浓的“故事会”既视感，这就是本书给我最大的感觉。第一次读马伯庸的书，所以之前不了解他的笔触。在本书中，说的是什么呢？一个普通的动物园故事？一个传教士的故事？一个关于赤峰和其信仰的故事？还是说底层百姓的愚昧无知的故事？我不知道。（有人把这比成赤峰的少年pi，我倒是没想到）。故事在紧要关头，用奇幻色彩来过渡；在一些转折点，则一笔带过，感觉纯粹是为了写故事而写故事，这不就是一个故事会的超长篇小说吗？这个感觉非常相似，也算是说明在我读来，文笔和内容都稍显简单。也可能是我对赤峰不够熟悉，或者读得不够透彻吧。anyway，总体感觉一般。
+0	什么鬼。。
+0	姐夫和小姨子，三观感人。而且模仿吴侬软语看的人好累，不太好看，文笔也一般，属于想要模仿匪我思存但非常失败的类型。
+0	王朔、石康、冯唐，文风和题材差球不多，才华却一代不如一代……
+0	絮絮叨叨 磨磨唧唧 啰啰嗦嗦，简直就像一部乡下老太太的流水账！没有逻辑 没有重点，对于部分精彩的故事，例如第四次东征和对抗蒙古人的东征，竟然也只用一两页纸就说完了？！你如此简练的文笔为啥要写出400多页的长文？！对于一个对十字军有兴趣的读者来说，这本书实在不适合阅读，差评！
+0	终于看完了 其实我觉得好没劲呀 要不是因为lp的名声我绝对不会耐着性子把它看完的
+0	诚然，这世界有着极致的阴暗，光明才更值得被追求。
+0	书名很吓人，但这只是其中的一个短篇。一本不温不火的私人回忆录，无感。
+0	因为喜欢封皮的黄色和女主角直子的名字而买了这本书，可是开头看了20页就实在看不下去了。是多么自负的作者才能写出如此自负的男主人公呢，是想写出男主的器宇轩昂，还是就是想塑造这么个雄赳赳的男主来衬托谦虚的女主，总之我是没看下去，试了好几次，每看一次心中就对男主产生极度的厌恶之情，最后这本新书还是送人了。如果是单纯的想看游记的话，这本绝对是下下之选，当小说看也不推荐，总之，差！
+0	越看到后面越受不了，你说从头和一个男的虐到尾不挺好的？
+0	李敖的史观旧得想吐槽都无处下嘴。
+0	难怪被喷，完全就是把新闻改编一下，打上小说的旗号。
+0	不是很喜欢
+0	看简介说宏观经济学理论和政策的颠覆之作。以人的非理性行为来解释经济，我兴致勃勃看了，仿佛进了餐馆打算吃顿大餐，前菜麻麻，我忍耐着吃了了，以为终于可以一尝正餐，结果它撤台了。一本书可说大半是废话，咂咂嘴感觉吃了顿西北风。
+0	这本在线即时翻译型译文毁原著。希望其他出版社重新出译本。英语语法的从句是最不好翻译成中文的，一旦按照英文习惯断句，就会存在没主语、或者主宾混乱的情况。
+0	这本的翻译看得真不是一般的别扭，倒不是文句不通而是归化腔太重了，实在看不习惯一股京片子味道的日本散文。文章内容本身也相当散乱，而且除了打火机和蜡像那两篇之外毫无作者特有的那种风格，只觉得是没什么实质内容的中国二流杂志随笔而已。
+0	无奈仍是无奈，疲惫仍是疲惫，原封不动。
+0	对白太拖拉。。比凤囚凰差了好多。。弃了，看了一半不到吧
+0	发现中国的小说家真的特别爱用高频次的对话来推进情节，因此对人物的理解也显得非常轻浮和表面，叙事几乎没有“停下来”的时候。而且这样一个很流水账的故事只是复刻了余华在活着或许三观卖血记中的苦难世界，属于自己的风格在哪里？用了很短的时间就几乎通读完全书，说实话，对于能读得这么快的长篇，向来警惕。
+0	两星实属无奈。虽然女主差强人意，可是男主男配和故事都不差。然而！！作者实在是太爱卖弄文采和诗词了，觉得行文不够连贯，让人厌烦，看起来累得要死。对作者文笔真没好感，不然起码三星吧。
+0	我一直觉得这书的出版是因为肥猪流的兴起
+0	翻译很烂，读不下去，以后有空读读英文版的吧。
+0	我想我一定没能看懂小说背后的意思~~~
+0	很乏味
+0	跟大马士革也就半毛钱的关系吧~宣传软文写得精彩正篇灰常1般，人物名字起得实在太土影响阅读...于是不耐烦地翻完了~
+0	看封面和书名本以为是一本治愈系作品，没想到却是一本暗黑故事集，虽说我承认作者的脑洞很大，但文笔远远跟不上他的脑洞，整篇作品文风矫揉造作，为显示逼格如呓语一般不知所云，充斥着一股非主流的味道！
+0	可不怎么好看
+1	那时候县里有一个借书的店，一毛钱一天。借过的最喜欢的一本。
+1	最大的新颖就是其不同于传统史学的论述视角，不仅没有为现代学术诟病的正朔之争，更摆脱了以中原王朝为视野立足点的习惯，纯粹地以北方草原为本位，贯通式地鸟瞰了整个古代草原世界，是一本通史型的著作。尽管在细节的讨论上仍然存在着太多可商榷的地方，但弥足珍贵之处在于巴氏给出了一个全新的认识角度。很多评论总要提及所谓的人类学视角，其实细看可以发现，书中并没有对人类学中的族群、族团做过任何的分析，哪怕民族认同这样的共同体标志也未被提起过。可见，巴氏的分析更多地还是基于历史学构架，期望通过区分主观史学与客观史学的分野来达到认识的新途径。
+1	作为强迫症，p256注释2“雪山女生之子”这个很想改过来。
+0	论见识和文学能力，此书都很差劲，如果说这本书背后代表的意义更重于书本身的内容，我是信的。只是，还是不值得给两颗以上的星，若是早半个世纪，恐好评如潮。
+0	没有故事性的小说即使包裹在再华美的文字下也是苍白，何况整本书连华美的文字都没有。我宁愿回去重新复习誓鸟和水仙！
+1	经历过那样不忍述说的灾难，回家那条漫长的，充斥着死亡、流离和痛苦的道路，在作者笔下竟然像被镀上一层带有暖意的阳光，有信仰、勇气和爱，真心难得。
+1	一个人的旅途 这会是好的选择
+1	耐读。导演很坦诚。还以为鳗鱼和楢山节考会有大篇幅的拍摄细节讲述，结果只是随笔一提，挺纳闷~
+1	我以前从未意识到德国的统一意味着普鲁士光辉灿烂地走向毁灭  这世界是你的遗嘱 而我是你唯一的遗物 其实我真正想看的只有最后四分之一 可以脑补万字独普独虐文了
+1	真的是一本巨著！虽然我自己更喜欢的是荒野侦探，但是2666有一种让人无法忽视的伟大。
+1	就看在這麼刷三觀的份兒上什麼書寫排版上的毛病都不是問題。。。
+0	这部不好看，第一部惊喜，第二部一般，能看完，第三部看了一部分再也看不下去了。
+0	读了几页就读不下去的...矫情
+0	正好在接触残疾人补贴事物，发现扶贫是个长远工程，非单纯给钱就能完成。
+1	“如果我们最后只能在地狱城上岸，我们有两种避免受苦的办法，对于许多人，第一种比较容易，接受地狱并且成为它的一部分，这样就不必看见它。第二种有些风险，而且必须时刻警惕提防：在地狱里找出非地狱的人和物，学习认识他们，让它们持续下去，给他们空间。”
+1	混乱的世界与和它一样混乱的青春
+1	谢谢黄同学赠书
+0	铺垫的太多了看到一半实在看不下去 情节能不能紧凑点
+1	可以说是资本论的通俗版，因为通俗丢失了一些东西，但也因此更容易让人看懂，好书
+0	这书真是无趣到了极点……
+1	英文书还是读原版。与保尔森、伯南克的书互为印证
+0	看了等于没看，还浪费时间的书
+0	虽然还是在胡说，但程度上似乎比前两部少了一些。
+1	大部头的小说
+0	这类充满灰暗内容、负能量的小说都应该扔垃圾堆里烧了
+1	读了两遍都没��懂。。。。
+0	所谓的闲笔或者自谓的这种也可称之为的“叙诡”于故事本身是毫无作用的，炫技有时不到点上确实很难堪
+0	垃圾中的战斗机
+0	白送我都不稀罕。
+0	其实观点还阔以，非得他妈不说正常人话，拽个鸡巴
+1	深入浅出，结合史实、材料的学术文，四星起
+1	看的是译言网的中译版本，极大满足了我的猎奇心理啊。从外国人的眼光看中国社会果然不一样
+1	有太多的思绪而至内心更加空洞，最后尼采透露出的一部分自我让读者和他自己都得到了救赎，有人说，人是为了幸福而活，人永远需要爱，也需要付出爱，而哲学似乎不会给予该怎么生活的答案，就如尼采所诉，这条路只能自己寻找。无论对自我的局限走到哪里，只要做出选择，就去爱这选择，虽然不会被治愈，但至少被慰籍。
+0	前半部还比较好，后半部就有点不紧凑。
+1	虽然写的比较浅，好歹让人对大中东有个基本概念，另外图文并茂的看着也舒服
+1	读了一半，还行吧，没有当年《奇迹的黄昏》带给我的震撼大。作者的叙述总有一点悲天悯人的调调，本质上来说，我是一个乐观的人，所以看着有点憋屈。当然作者的观点，给我很多启发，但是论述的逻辑性尚缺严密。
+1	首先看的是伊伯特的纪录片“人生如戏”，后来一直想找来此书一读，奈何过于火爆，至今日才在图书馆预约到。多每部电影的影评，提及的电影也大都看过，但共鸣点委实不一样。更觉哈姆雷特不止一个，和经历观念太相关了。许多更伟大的电影未提及，也算遗憾。
+1	过程像行尸走肉，结局像迷雾
+1	言简意赅，处处都是精华
+0	太无聊的阴谋论。
+1	一口气读完 很喜欢。尤其是这本书里关维兴的插画 很喜欢。
+0	补记/看不下去啊～
+1	纸上谈兵的截图指南，推荐。
+0	粗读。都是观点，没有数据和事例。
+0	2017-15 未雨绸缪四个字说得那么复杂
+1	好畅快
+1	入门之作
+0	天马行空，欣赏不来
+0	我想了一下这本书被大力推崇,乃至"改变了对明朝的固有看法",然后就是推什么天子守国门之类的.在这类读者看来,气节之类是最重要的(说起来明朝最讲气节的几个反而不是真的气节),至于锦衣卫,东西厂之类则被视作不存在.晚明的颓丧糜烂风气也被视为一种明朝活力的象征.无论如何吹,明朝绝对不是几个长期王朝里最强的,甚至宋也算不了.唐朝的强在于儒教在此一朝只是多元中的一部分(中晚唐儒教重起,儒生又无法控制藩镇武人,则唐归于毁灭)
+0	这书我看了一年还没看完，断断续续，弃了看，看了弃，实在是无法一口气读下去。。故事是个好故事，可是文笔也太啰嗦了。。。
+0	非常令人失望
+0	死亡让一切平庸显得伟大；这叫做尸体的浮肿。
+1	没有耐心的就不要读了，完全没有八卦好么
+0	飞行读物。翻译的不错很细腻。也从书里看见自己虽对前路迷茫也不会沉浸在过去了。
+0	越读越涩，涩到煎熬
+0	佩服作者的观察力和毅力，但是一点可读性都没有，干巴巴的。
+1	此书的靠谱程度和好莱坞每年出产的烂片数量形成了奇妙的对比。
+1	案例值得深思
+0	看到这样的文我就觉得网络文学的质量果然还是正常的
+1	写史一绝，没有矫揉造作，没有铁血刚硬，可以深深地体味对历史的敬畏和温情，文字辛辣，却没有语言的偏激，这其中包含着文人墨客对中国政治自古的追索，让人心酸，让人欣慰，值得铭想。
+1	很容易看下去，简单但是有深度，与历史结合的写法非常有趣
+1	比较全
+0	想法不错，一上来还挺惊艳的，越看越不行，七拼八凑现学现卖的感觉，且文风恶俗，从头到尾毫无节制地贫嘴
+1	爽。
+1	……读完整个人魂灵都处在被勾走的状态QAQ 2001库神影像已先入为主了 想给2001一万颗星TvT（“God, it's full of stars!!!!!”（。 神一样的思维设定基础 觉得2010可读性最强（……虽然被电影作用了从土星转成了木星=。= 2061有点水 3001就真的……唉说不出话了QAQ “你我所拥有的自由，只怕比想像中还要少。”（btw 这真的是目前最棒的生日礼物QAQ
+0	真的很一般啊
+0	矫情逼
+1	毁城记
+0	零散的不成体系；自以为是的抒情 鸟人/法国中尉的女人/一个男人与一个女人/骗术大全/美国往事/罗拉快跑
+0	难以做出评价，很多不认同，so
+0	流水账一般
+1	作者对历史很有了解，小说夹杂历史，难得的好作品
+0	同学的书 凑合看完
+0	女主的性格倒不让人讨厌，只是看的时候心里总有个声音在说：“哪有这样的人。”很是心烦。东方非和凤一郎倒是很有意思，你们在一起吧。
+0	故事还可以，但感觉情节不够丰满，很多东西，都没清楚��代，有些转折有点生硬。文字感觉也比较一般。不是特别特别特别多时间的人不推荐阅读。
+0	真真切切的流水账，青春回忆+黑道+高干+富二代+绝世美颜（男主姐，法拉利家族二儿子拜倒裙下）+娱乐圈+天上人间+... 狗血再来得猛烈些吧！这真的是写《匆匆那年》的九夜茴么？就这还写了将近四十万字上下两册？作者神了， 出了这么多本书，还能来这么一部跟处女作网文一样的作品，真的不是把当年的出道作品拿出来充数了么？真的不是为了交差应付凑了一本？真的不是枪手在写大学开始的故事么？给跪了。留着的两星给幼年部分。一些对话和情节能透出纸张让人尴尬。
+0	我不明白他们为什么这样迷信野史
+0	唐七的小说除了那看似华丽的文字外，还有什么？读了唐七的华胥引和三生三世之后，我忽然觉得郭四娘的小说真是太特么好看了。唐七的小说和他的笔名一样，充满了装逼的气息。角色塑造也几乎和华胥引完全一样，两部小说的男主都是能力强悍的高冷系——装逼者的最爱，而女主则都是中二病带点转了几世的小忧伤......呵呵，您能稍微突破下自己，多少有点创意吗？
+1	感觉很无聊~但是刚推出是看豆瓣评到8.多就下手了
+1	希望我看的不是删节版的。
+0	已经不能读中文小说了，太难看了，尤其是里面对女性角色的刻画，真是丢人。
+1	「即便你是個僧侶，像我哥哥那樣，盛怒或屠殺也會在某天找上門來。因為沒有社會的存在你也無法以僧侶的身份生存。你摒棄社會種種，但要達成這一目標必須先成為它的一分子，從中學習並做出決斷。這是歸隱的悖論。」  / 四五年前第一次接觸到這本書的時候，是台灣譯者的翻譯，書名叫《菩薩凝望的島嶼》。前段時間朋友在力推這本書我以為是翁達傑的新書，之前並沒有注意到英文名，後來一查，才知道是同一本。但無論是哪個翻譯，都覺得蠻好的。幾年後再讀是另一種完全不同的感覺。我不得不喜歡那個「買」了她哥哥的名字 ——「安尼爾」的女法醫人類學專家。
+0	越写越恶心  妈呀  这样的女主  太长的文  必然问题颇多
+1	经常看到默默流泪……
+1	2015年读完的，还行吧！
+1	很喜欢，再多读几遍
+0	蒂莫西·加顿艾什的《档案》《事实即颠覆》都很差！
+0	这种意识流的看点在哪？
+1	感觉自己被祖伊训的狗血喷头 但结尾有点马虎啊 不能拿大哥作幌子啊
+0	这算哪门子的纯文学
+0	行文过于流水帐，不推荐阅读
+0	其实除了一点历史之外看不出男女主有什么时代差异
+0	原来以为还可以，看完发现相当无聊。
+1	与其说是创业的国度，不如说是创新的国度，可是一个国度的创新背后往往是它一路走来，甚至永远摆脱不掉的民族血泪。所谓多难兴邦，或许也有这层意味。
+1	一百个赞
+1	奇遇的重演
+1	创新是这个世界保持增长的根本原因，创新需要知识技术及载体（人类和人工智能）。我们这个世界与几万年前人类祖先智人生活的世界的不同之处在于物理秩序（信息）的不同，现在处于信息爆炸的时代，不同的知识技术储存在不同的个体、组织中，要想持续不断地创新就要扩大我们的社会关系网络，以获得更多的知识技术和计算能力，所以，链接越来越重要。
+1	宋朝部分写的太好了
+1	印象很深的就是罗斯福想要帮助英国抗衡德国，每一步都很艰难，要说服国会说服人民，反观日本德国，希特勒，军部说一不二，制度的差距如此大。
+0	好脑残的，诧异能印出来
+1	专业影评写作指南
+0	屁话多！！就是说这个好，这个重要。一点都不深入，中信居然给出版了，噱头大啊！！第三次工业革命并不仅仅围绕能源，也不仅仅是核电风电光伏！！
+0	开篇便是甩掉你的坏旅伴，但后面就是一个complain的集合体，最后再凸显一下我能忍受着一切，牛逼吧。看来看去，整本书写的最好的部分是写给自己旅伴的孩子的信。也许真人是个有趣的人，但落实到文字上就算了。
+1	对俺来说有点专业，但是确实对了解黑色电影很有用
+0	俗
+1	儒家文明PK海洋强盗文化，尘归尘土归土，全球化的今天，谁都不可能幸免。中国人真的有必要一直勤劳勇敢朴素下去吗？不劳动真的那么可耻吗？今天的中国会有不同于100年前的命运选择吗？一起拭目以待吧。。。话说，希腊政府真是够可耻的！！
+0	把先贤们都说过的事情拼凑一下，炒冷饭。有点无聊，最多2星……
+1	被我发现了刊印错误……比较实用的一本书，但是写影评最重要的部分是对电影知识的了解和笔头功夫，所以练习更重要。
+0	目的性太强
+1	自己看过的编剧类书籍中，内容最完整的一本。它涉及的面更广，不仅是一本剧本写作指南，也是一个(好莱坞)编剧从业指南。
+1	故事的主题是创新
+0	玛丽苏，拉分数的我。这书名无语了
+1	新晋男神。
+1	我记得我有两本来着
+1	很不错
+1	看到毕业礼那里确实挺心酸的，小时候我也像弗兰西那样的爱爸爸。
+1	似懂非懂。
+1	这是我读的第一本钱先生的书，当初的那种醍醐灌顶之感如今还清晰可感，不管怎样，我算是读到了一些东西。
+0	好失望~
+0	看完觉得很恶心，不能认同作者的观点，怎么豆瓣评价这么高？
+0	凉生，我们可不可以不这么作……
+0	烂书一本。
+1	很美丽的地方，喜欢作者摘的那些水果
+0	不知道该说是资本主义的虚伪，还是人性的虚伪。
+1	语言圆润 论点偏大众
+0	动机真的是青春期中二症典型例子...
+0	图表上的字太大，影响了图表的直观性。
+0	描写知识分子们在新中国成立后第一次政治运动中遭遇和表现的小说，然而却仅仅停留在历史场景的复述和控诉上，缺乏深层次的批判和思考；写法手法上也没有太多的技巧可言。看完卡夫卡和昆德拉的作品，再来读这本《洗澡》，实在有味同嚼蜡的感觉。
+1	知我者，谓我心忧；不知我者，谓我何求。   历史的误会。
+0	原来《庶女有毒》换了个名字出版。非常长的宅斗文，女主金手指大开，初看非常爽，再看经不起推敲。听说是抄袭了一百多本书，可怕。仔细看的话用词和标点符号都非常不到位，很幼稚。李长乐的美若天仙和智商真是不成正比，蒋家五个最优秀的儿子全都死了，算计人和吃白菜似的。
+0	你丫知道什么是纪事本末吗
+1	街上那点事儿。翻译不错，可以一看。
+0	好长好无聊，可怜的端午假期
+1	依然如此吸引人，但是有些郁闷，感觉比呐喊更阴暗些。不知为何极喜欢魏连殳。
+0	差。
+0	最后直接叫朋友说了结局，没了闲情看下去。
+0	一出闹剧。如果说秋菊是轴，那么李雪莲就是作。小说里的人名：王公道 董宪法 荀正义 史为民 储清廉，真是受不了这种赤裸裸的反讽。先不管小说写的怎么样，反正读起来感觉很不好就是了。。囧rz
+1	终于搞清来龙去脉
+1	高二时候读的，记忆深刻
+0	非常差。各种不靠谱。没有什么当地的风土人情，只有作者貌似站的很高的感叹。自我感觉太良好了吧
+0	电影挺喜欢的，故事也挺喜欢的，可是这本书的翻译啊，真的好敷衍
+1	酣畅淋漓
+0	我不懂评分为什么这么高，太扯了
+0	就冲这出版社的社品。。。尼玛一星都配不上！！！
+0	浓浓的直男癌口气…好恶心…
+0	忘不掉过去，就很难得到现在和未来的幸福，那种抱着过去和现在死磕的人最讨厌了！
+0	1.作者何必不断强调自己是乡下人？你若看得起自己 没人看不起你 2.我还真不知道星巴克里除了美式之外两杯咖啡才收37元钱 3.这感情真是你麻痹来的莫名其妙 4.这个和何以完全不是一个档次的 何以比这个好看一千万倍不止。
+0	王朔也就一街头低端草泥马
+0	完全get不到点的男女关系
+0	倾向性太明显了吧……
+1	曾经如此，此后不再。要记得。
+0	烂！！
+0	白左垃圾
+0	废话太多 看到第三页就会忘了第一页说了什么 可能是我悟性太差吧
+1	对侯导的作品又多了一些了解。

train/datasets/test_data/book_review/test_nolabel.tsv

@@ -0,0 +1,201 @@
+text_a
+我惊了，这些评论的人真的都看了这书吗？还是都是托.....
+男主好渣！看的气死我了！
+大概初中及初中以下水平读者会把这奉为神作吧。今何在构建作品里抹不掉的中二气。
+编辑肯定约稿时候反复提及以“艳遇”为中心了。然后作孽般的拼凑成这么一本破书。都神马水平啊这。
+我是读不下去了……
+严重过誉，斯蒂芬·茨威格这历史观以及叙事的方式和内容，就好像在看现代人拍的古装剧。最无法认同他将历史进程归咎于某些人的一念之差
+太不真实
+手贱的代价。神马傻逼玩意儿
+算......黑历史吧......= =
+一向的风格。懒得说了。
+一开始还挺好看的，可是后面就烂尾了…不停地分手在一起分手在一起……还穿越…唉
+不懂为什么分这么高 我觉得这书的内容真的很一般
+如果不是宣传吹嘘得太夸张，和预想相差甚远的话，或许我给的是三星。失望是最可怕的。
+不多说了。
+看完有一种杀了作者的冲动。这年头是什么人都可以出书了么，三联你要不要这么砸自己的牌子啊！
+翻译之差，无出其右
+当初看的网络连载版，说真的这文到后面越来越崩坏，谁能告诉我女主这么穿越的意义究竟何在？虽然出了大事故，但原来的生活很美好啊。如果走穿后的那一条线也就算了，可以理解为想让男女主早点遇见，可问题是后面又回去了是要闹哪样？感觉此作者的作品没有以前的好看了
+yy得太过分了，文笔普通，还披着软文伪网游的皮……………………又一个得分很高实际很烂的瞎文= =。
+浓浓的“故事会”既视感，这就是本书给我最大的感觉。第一次读马伯庸的书，所以之前不了解他的笔触。在本书中，说的是什么呢？一个普通的动物园故事？一个传教士的故事？一个关于赤峰和其信仰的故事？还是说底层百姓的愚昧无知的故事？我不知道。（有人把这比成赤峰的少年pi，我倒是没想到）。故事在紧要关头，用奇幻色彩来过渡；在一些转折点，则一笔带过，感觉纯粹是为了写故事而写故事，这不就是一个故事会的超长篇小说吗？这个感觉非常相似，也算是说明在我读来，文笔和内容都稍显简单。也可能是我对赤峰不够熟悉，或者读得不够透彻吧。anyway，总体感觉一般。
+什么鬼。。
+姐夫和小姨子，三观感人。而且模仿吴侬软语看的人好累，不太好看，文笔也一般，属于想要模仿匪我思存但非常失败的类型。
+王朔、石康、冯唐，文风和题材差球不多，才华却一代不如一代……
+絮絮叨叨 磨磨唧唧 啰啰嗦嗦，简直就像一部乡下老太太的流水账！没有逻辑 没有重点，对于部分精彩的故事，例如第四次东征和对抗蒙古人的东征，竟然也只用一两页纸就说完了？！你如此简练的文笔为啥要写出400多页的长文？！对于一个对十字军有兴趣的读者来说，这本书实在不适合阅读，差评！
+终于看完了 其实我觉得好没劲呀 要不是因为lp的名声我绝对不会耐着性子把它看完的
+诚然，这世界有着极致的阴暗，光明才更值得被追求。
+书名很吓人，但这只是其中的一个短篇。一本不温不火的私人回忆录，无感。
+因为喜欢封皮的黄色和女主角直子的名字而买了这本书，可是开头看了20页就实在看不下去了。是多么自负的作者才能写出如此自负的男主人公呢，是想写出男主的器宇轩昂，还是就是想塑造这么个雄赳赳的男主来衬托谦虚的女主，总之我是没看下去，试了好几次，每看一次心中就对男主产生极度的厌恶之情，最后这本新书还是送人了。如果是单纯的想看游记的话，这本绝对是下下之选，当小说看也不推荐，总之，差！
+越看到后面越受不了，你说从头和一个男的虐到尾不挺好的？
+李敖的史观旧得想吐槽都无处下嘴。
+难怪被喷，完全就是把新闻改编一下，打上小说的旗号。
+不是很喜欢
+看简介说宏观经济学理论和政策的颠覆之作。以人的非理性行为来解释经济，我兴致勃勃看了，仿佛进了餐馆打算吃顿大餐，前菜麻麻，我忍耐着吃了了，以为终于可以一尝正餐，结果它撤台了。一本书可说大半是废话，咂咂嘴感觉吃了顿西北风。
+这本在线即时翻译型译文毁原著。希望其他出版社重新出译本。英语语法的从句是最不好翻译成中文的，一旦按照英文习惯断句，就会存在没主语、或者主宾混乱的情况。
+这本的翻译看得真不是一般的别扭，倒不是文句不通而是归化腔太重了，实在看不习惯一股京片子味道的日本散文。文章内容本身也相当散乱，而且除了打火机和蜡像那两篇之外毫无作者特有的那种风格，只觉得��没什么实质内容的中国二流杂志随笔而已。
+无奈仍是无奈，疲惫仍是疲惫，原封不动。
+对白太拖拉。。比凤囚凰差了好多。。弃了，看了一半不到吧
+发现中国的小说家真的特别爱用高频次的对话来推进情节，因此对人物的理解也显得非常轻浮和表面，叙事几乎没有“停下来”的时候。而且这样一个很流水账的故事只是复刻了余华在活着或许三观卖血记中的苦难世界，属于自己的风格在哪里？用了很短的时间就几乎通读完全书，说实话，对于能读得这么快的长篇，向来警惕。
+两星实属无奈。虽然女主差强人意，可是男主男配和故事都不差。然而！！作者实在是太爱卖弄文采和诗词了，觉得行文不够连贯，让人厌烦，看起来累得要死。对作者文笔真没好感，不然起码三星吧。
+我一直觉得这书的出版是因为肥猪流的兴起
+翻译很烂，读不下去，以后有空读读英文版的吧。
+我想我一定没能看懂小说背后的意思~~~
+很乏味
+跟大马士革也就半毛钱的关系吧~宣传软文写得精彩正篇灰常1般，人物名字起得实在太土影响阅读...于是不耐烦地翻完了~
+看封面和书名本以为是一本治愈系作品，没想到却是一本暗黑故事集，虽说我承认作者的脑洞很大，但文笔远远跟不上他的脑洞，整篇作品文风矫揉造作，为显示逼格如呓语一般不知所云，充斥着一股非主流的味道！
+可不怎么好看
+那时候县里有一个借书的店，一毛钱一天。借过的最喜欢的一本。
+最大的新颖就是其不同于传统史学的论述视角，不仅没有为现代学术诟病的正朔之争，更摆脱了以中原王朝为视野立足点的习惯，纯粹地以北方草原为本位，贯通式地鸟瞰了整个古代草原世界，是一本通史型的著作。尽管在细节的讨论上仍然存在着太多可商榷的地方，但弥足珍贵之处在于巴氏给出了一个全新的认识角度。很多评论总要提及所谓的人类学视角，其实细看可以发现，书中并没有对人类学中的族群、族团做过任何的分析，哪怕民族认同这样的共同体标志也未被提起过。可见，巴氏的分析更多地还是基于历史学构架，期望通过区分主观史学与客观史学的分野来达到认识的新途径。
+作为强迫症，p256注释2“雪山女生之子”这个很想改过来。
+论见识和文学能力，此书都很差劲，如果说这本书背后代表的意义更重于书本身的内容，我是信的。只是，还是不值得给两颗以上的星，若是早半个世纪，恐好评如潮。
+没有故事性的小说即使包裹在再华美的文字下也是苍白，何况整本书连华美的文字都没有。我宁愿回去重新复习誓鸟和水仙！
+经历过那样不忍述说的灾难，回家那条漫长的，充斥着死亡、流离和痛苦的道路，在作者笔下竟然像被镀上一层带有暖意的阳光，有信仰、勇气和爱，真心难得。
+一个人的旅途 这会是好的选择
+耐读。导演很坦诚。还以为鳗鱼和楢山节考会有大篇幅的拍摄细节讲述，结果只是随笔一提，挺纳闷~
+我以前从未意识到德国的统一意味着普鲁士光辉灿烂地走向毁灭  这世界是你的遗嘱 而我是你唯一的遗物 其实我真正想看的只有最后四分之一 可以脑补万字独普独虐文了
+真的是一本巨著！虽然我自己更喜欢的是荒野侦探，但是2666有一种让人无法忽视的伟大。
+就看在這麼刷三觀的份兒上什麼書寫排版上的毛病都不是問題。。。
+这部不好看，第一部惊喜，第二部一般，能看完，第三部看了一部分再也看不下去了。
+读了几页就读不下去的...矫情
+正好在接触残疾人补贴事物，发现扶贫是个长远工程，非单纯给钱就能完成。
+“如果我们最后只能在地狱城上岸，我们有两种避免受苦的办法，对于许多人，第一种比较容易，接受地狱并且成为它的一部分，这样就不必看见它。第二种有些风险，而且必须时刻警惕提防：在地狱里找出非地狱的人和物，学习认识他们，让它们持续下去，给他们空间。”
+混乱的世界与和它一样混乱的青春
+谢谢黄同学赠书
+铺垫的太多了看到一半实在看不下去 情节能不能紧凑点
+可以说是资本论的通俗版，因为通俗丢失了一些东西，但也因此更容易让人看懂，好书
+这书真是无趣到了极点……
+英文书还是读原版。与保尔森、伯南克的书互为印证
+看了等于没看，还浪费时间的书
+虽然还是在胡说，但程度上似乎比前两部少了一些。
+大部头的小说
+这类充满灰暗内容、负能量的小说都应该扔垃圾堆里烧了
+读了两遍都没读懂。。。。
+所谓的闲笔或者自谓的这种也可称之为的“叙诡”于故事本身是毫无作用的，炫技有时不到点上确���很难堪
+垃圾中的战斗机
+白送我都不稀罕。
+其实观点还阔以，非得他妈不说正常人话，拽个鸡巴
+深入浅出，结合史实、材料的学术文，四星起
+看的是译言网的中译版本，极大满足了我的猎奇心理啊。从外国人的眼光看中国社会果然不一样
+有太多的思绪而至内心更加空洞，最后尼采透露出的一部分自我让读者和他自己都得到了救赎，有人说，人是为了幸福而活，人永远需要爱，也需要付出爱，而哲学似乎不会给予该怎么生活的答案，就如尼采所诉，这条路只能自己寻找。无论对自我的局限走到哪里，只要做出选择，就去爱这选择，虽然不会被治愈，但至少被慰籍。
+前半部还比较好，后半部就有点不紧凑。
+虽然写的比较浅，好歹让人对大中东有个基本概念，另外图文并茂的看着也舒服
+读了一半，还行吧，没有当年《奇迹的黄昏》带给我的震撼大。作者的叙述总有一点悲天悯人的调调，本质上来说，我是一个乐观的人，所以看着有点憋屈。当然作者的观点，给我很多启发，但是论述的逻辑性尚缺严密。
+首先看的是伊伯特的纪录片“人生如戏”，后来一直想找来此书一读，奈何过于火爆，至今日才在图书馆预约到。多每部电影的影评，提及的电影也大都看过，但共鸣点委实不一样。更觉哈姆雷特不止一个，和经历观念太相关了。许多更伟大的电影未提及，也算遗憾。
+过程像行尸走肉，结局像迷雾
+言简意赅，处处都是精华
+太无聊的阴谋论。
+一口气读完 很喜欢。尤其是这本书里关维兴的插画 很喜欢。
+补记/看不下去啊～
+纸上谈兵的截图指南，推荐。
+粗读。都是观点，没有数据和事例。
+2017-15 未雨绸缪四个字说得那么复杂
+好畅快
+入门之作
+天马行空，欣赏不来
+我想了一下这本书被大力推崇,乃至"改变了对明朝的固有看法",然后就是推什么天子守国门之类的.在这类读者看来,气节之类是最重要的(说起来明朝最讲气节的几个反而不是真的气节),至于锦衣卫,东西厂之类则被视作不存在.晚明的颓丧糜烂风气也被视为一种明朝活力的象征.无论如何吹,明朝绝对不是几个长期王朝里最强的,甚至宋也算不了.唐朝的强在于儒教在此一朝只是多元中的一部分(中晚唐儒教重起,儒生又无法控制藩镇武人,则唐归于毁灭)
+这书我看了一年还没看完，断断续续，弃了看，看了弃，实在是无法一口气读下去。。故事是个好故事，可是文笔也太啰嗦了。。。
+非常令人失望
+死亡让一切平庸显得伟大；这叫做尸体的浮肿。
+没有耐心的就不要读了，完全没有八卦好么
+飞行读物。翻译的不错很细腻。也从书里看见自己虽对前路迷茫也不会沉浸在过去了。
+越读越涩，涩到煎熬
+佩服作者的观察力和毅力，但是一点可读性都没有，干巴巴的。
+此书的靠谱程度和好莱坞每年出产的烂片数量形成了奇妙的对比。
+案例值得深思
+看到这样的文我就觉得网络文学的质量果然还是正常的
+写史一绝，没有矫揉造作，没有铁血刚硬，可以深深地体味对历史的敬畏和温情，文字辛辣，却没有语言的偏激，这其中包含着文人墨客对中国政治自古的追索，让人心酸，让人欣慰，值得铭想。
+很容易看下去，简单但是有深度，与历史结合的写法非常有趣
+比较全
+想法不错，一上来还挺惊艳的，越看越不行，七拼八凑现学现卖的感觉，且文风恶俗，从头到尾毫无节制地贫嘴
+爽。
+……读完整个人魂灵都处在被勾走的状态QAQ 2001库神影像已先入为主了 想给2001一万颗星TvT（“God, it's full of stars!!!!!”（。 神一样的思维设定基础 觉得2010可读性最强（……虽然被电影作用了从土星转成了木星=。= 2061有点水 3001就真的……唉说不出话了QAQ “你我所拥有的自由，只怕比想像中还要少。”（btw 这真的是目前最棒的生日礼物QAQ
+真的很一般啊
+矫情逼
+毁城记
+零散的不成体系；自以为是的抒情 鸟人/法国中尉的女人/一个男人与一个女人/骗术大全/美国往事/罗拉快跑
+难以做出评价，很多不认同，so
+流水账一般
+作者对历史很有了解，小说夹杂历史，难得的好作品
+同学的书 凑合看完
+女主的性格倒不让人讨厌，只是看的时候心里总有个声音在说：“哪有这样的人。”很是心烦。东方非和凤一郎倒是很有意思，你们在一起吧。
+故事还可以，但感觉情节不够丰满，很多东西，都没清楚交代，有些转折有点生硬。文字感觉也比较一般。不是特别特别特别多时间的人不推荐阅读。
+真真切切的流水账，青春回忆+黑道+高干+富二代+绝世美颜（男主姐，法拉利家族二儿子拜倒��下）+娱乐圈+天上人间+... 狗血再来得猛烈些吧！这真的是写《匆匆那年》的九夜茴么？就这还写了将近四十万字上下两册？作者神了， 出了这么多本书，还能来这么一部跟处女作网文一样的作品，真的不是把当年的出道作品拿出来充数了么？真的不是为了交差应付凑了一本？真的不是枪手在写大学开始的故事么？给跪了。留着的两星给幼年部分。一些对话和情节能透出纸张让人尴尬。
+我不明白他们为什么这样迷信野史
+唐七的小说除了那看似华丽的文字外，还有什么？读了唐七的华胥引和三生三世之后，我忽然觉得郭四娘的小说真是太特么好看了。唐七的小说和他的笔名一样，充满了装逼的气息。角色塑造也几乎和华胥引完全一样，两部小说的男主都是能力强悍的高冷系——装逼者的最爱，而女主则都是中二病带点转了几世的小忧伤......呵呵，您能稍微突破下自己，多少有点创意吗？
+感觉很无聊~但是刚推出是看豆瓣评到8.多就下手了
+希望我看的不是删节版的。
+已经不能读中文小说了，太难看了，尤其是里面对女性角色的刻画，真是丢人。
+「即便你是個僧侶，像我哥哥那樣，盛怒或屠殺也會在某天找上門來。因為沒有社會的存在你也無法以僧侶的身份生存。你摒棄社會種種，但要達成這一目標必須先成為它的一分子，從中學習並做出決斷。這是歸隱的悖論。」  / 四五年前第一次接觸到這本書的時候，是台灣譯者的翻譯，書名叫《菩薩凝望的島嶼》。前段時間朋友在力推這本書我以為是翁達傑的新書，之前並沒有注意到英文名，後來一查，才知道是同一本。但無論是哪個翻譯，都覺得蠻好的。幾年後再讀是另一種完全不同的感覺。我不得不喜歡那個「買」了她哥哥的名字 ——「安尼爾」的女法醫人類學專家。
+越写越恶心  妈呀  这样的女主  太长的文  必然问题颇多
+经常看到默默流泪……
+2015年读完的，还行吧！
+很喜欢，再多读几遍
+蒂莫西·加顿艾什的《档案》《事实即颠覆》都很差！
+这种意识流的看点在哪？
+感觉自己被祖伊训的狗血喷头 但结尾有点马虎啊 不能拿大哥作幌子啊
+这算哪门子的纯文学
+行文过于流水帐，不推荐阅读
+其实除了一点历史之外看不出男女主有什么时代差异
+原来以为还可以，看完发现相当无聊。
+与其说是创业的国度，不如说是创新的国度，可是一个国度的创新背后往往是它一路走来，甚至永远摆脱不掉的民族血泪。所谓多难兴邦，或许也有这层意味。
+一百个赞
+奇遇的重演
+创新是这个世界保持增长的根本原因，创新需要知识技术及载体（人类和人工智能）。我们这个世界与几万年前人类祖先智人生活的世界的不同之处在于物理秩序（信息）的不同，现在处于信息爆炸的时代，不同的知识技术储存在不同的个体、组织中，要想持续不断地创新就要扩大我们的社会关系网络，以获得更多的知识技术和计算能力，所以，链接越来越重要。
+宋朝部分写的太好了
+印象很深的就是罗斯福想要帮助英国抗衡德国，每一步都很艰难，要说服国会说服人民，反观日本德国，希特勒，军部说一不二，制度的差距如此大。
+好脑残的，诧异能印出来
+专业影评写作指南
+屁话多！！就是说这个好，这个重要。一点都不深入，中信居然给出版了，噱头大啊！！第三次工业革命并不仅仅围绕能源，也不仅仅是核电风电光伏！！
+开篇便是甩掉你的坏旅伴，但后面就是一个complain的集合体，最后再凸显一下我能忍受着一切，牛逼吧。看来看去，整本书写的最好的部分是写给自己旅伴的孩子的信。也许真人是个有趣的人，但落实到文字上就算了。
+对俺来说有点专业，但是确实对了解黑色电影很有用
+俗
+儒家文明PK海洋强盗文化，尘归尘土归土，全球化的今天，谁都不可能幸免。中国人真的有必要一直勤劳勇敢朴素下去吗？不劳动真的那么可耻吗？今天的中国会有不同于100年前的命运选择吗？一起拭目以待吧。。。话说，希腊政府真是够可耻的！！
+把先贤们都说过的事情拼凑一下，炒冷饭。有点无聊，最多2星……
+被我发现了刊印错误……比较实用的一本书，但是写影评最重要的部分是对电影知识的了解和笔头功夫，所以练习更重要。
+目的性太强
+自己看过的编剧类书籍中，内容最完整的一本。它涉及的面更广，不仅是一本剧本写作指南，也是一个(好莱坞)编剧从业指南。
+故事的主题是创新
+玛丽苏，拉分数的我。这书名无语了
+新晋男神。
+我记得我有两本来着
+很不错
+看到毕业礼那里��实挺心酸的，小时候我也像弗兰西那样的爱爸爸。
+似懂非懂。
+这是我读的第一本钱先生的书，当初的那种醍醐灌顶之感如今还清晰可感，不管怎样，我算是读到了一些东西。
+好失望~
+看完觉得很恶心，不能认同作者的观点，怎么豆瓣评价这么高？
+凉生，我们可不可以不这么作……
+烂书一本。
+很美丽的地方，喜欢作者摘的那些水果
+不知道该说是资本主义的虚伪，还是人性的虚伪。
+语言圆润 论点偏大众
+动机真的是青春期中二症典型例子...
+图表上的字太大，影响了图表的直观性。
+描写知识分子们在新中国成立后第一次政治运动中遭遇和表现的小说，然而却仅仅停留在历史场景的复述和控诉上，缺乏深层次的批判和思考；写法手法上也没有太多的技巧可言。看完卡夫卡和昆德拉的作品，再来读这本《洗澡》，实在有味同嚼蜡的感觉。
+知我者，谓我心忧；不知我者，谓我何求。   历史的误会。
+原来《庶女有毒》换了个名字出版。非常长的宅斗文，女主金手指大开，初看非常爽，再看经不起推敲。听说是抄袭了一百多本书，可怕。仔细看的话用词和标点符号都非常不到位，很幼稚。李长乐的美若天仙和智商真是不成正比，蒋家五个最优秀的儿子全都死了，算计人和吃白菜似的。
+你丫知道什么是纪事本末吗
+街上那点事儿。翻译不错，可以一看。
+好长好无聊，可怜的端午假期
+依然如此吸引人，但是有些郁闷，感觉比呐喊更阴暗些。不知为何极喜欢魏连殳。
+差。
+最后直接叫朋友说了结局，没了闲情看下去。
+一出闹剧。如果说秋菊是轴，那么李雪莲就是作。小说里的人名：王公道 董宪法 荀正义 史为民 储清廉，真是受不了这种赤裸裸的反讽。先不管小说写的怎么样，反正读起来感觉很不好就是了。。囧rz
+终于搞清来龙去脉
+高二时候读的，记忆深刻
+非常差。各种不靠谱。没有什么当地的风土人情，只有作者貌似站的很高的感叹。自我感觉太良好了吧
+电影挺喜欢的，故事也挺喜欢的，可是这本书的翻译啊，真的好敷衍
+酣畅淋漓
+我不懂评分为什么这么高，太扯了
+就冲这出版社的社品。。。尼玛一星都配不上！！！
+浓浓的直男癌口气…好恶心…
+忘不掉过去，就很难得到现在和未来的幸福，那种抱着过去和现在死磕的人最讨厌了！
+1.作者何必不断强调自己是乡下人？你若看得起自己 没人看不起你 2.我还真不知道星巴克里除了美式之外两杯咖啡才收37元钱 3.这感情真是你麻痹来的莫名其妙 4.这个和何以完全不是一个档次的 何以比这个好看一千万倍不止。
+王朔也就一街头低端草泥马
+完全get不到点的男女关系
+倾向性太明显了吧……
+曾经如此，此后不再。要记得。
+烂！！
+白左垃圾
+废话太多 看到第三页就会忘了第一页说了什么 可能是我悟性太差吧
+对侯导的作品又多了一些了解。

train/datasets/test_data/book_review/train.tsv

@@ -0,0 +1,501 @@
+label	text_a
+1	冷酷无情地细致描绘了失明症蔓延后的人间地狱，几乎不用形容词，没有任何形容词的分量足以承载书中的情境。只是讽刺、暗喻、描述，不煽动，不呼吁，绝望压抑到死。ps题外话，要是在中国，编辑首先得让你分分段，标清说话主体再来交稿。另，发现灾难题材里的“幸存者”通常都是女性。
+0	这么美的书名，这么sb的故事
+1	年轻时荒唐狂热过，所以才有老来的沉淀和思考。
+1	很奇特的一本书。。
+0	不喜欢。
+0	搞毛，女主你到底爱谁。
+1	挺有意思
+0	花一天，看完了，就是小白文，只不过加了个神的外衣，浪费时间，浪费时间！
+0	拿腔拿调了两百页，最后漏了珍珠翡翠白玉汤的底子。
+0	作为游记，过于流水账，革命之前年轻时候的格瓦拉的普通人生活
+1	写的通俗易懂，可以对以色列有更深的了解
+1	看这种淡淡的文字，冷静的叙述，最舒服不过，让人安静。和沈从文的味道很像
+0	借朋友书读的，她推荐时说本来很精彩的故事被删减的没了趣味。我读也就这个感觉,但故事情节仍让我感觉得到爱情的诡异之处
+1	笔记整理。理论高于实践的同时指导实践。
+1	把人的阴暗面描绘得真好！又发现了一个很喜欢的作家！
+0	看不下去+1，很早开了个头就没看下去，听说要拍电视剧，还是比较喜欢的演员演，就又开始看，这尼玛，依旧看得很痛苦，还是看不下去，我自认为很包容，很久没看到一篇像这样对我毫无吸引力的小说了，强迫症也不能让我补完，这也能改成电视剧？？？？刘诗诗又要演这种类型的？？？
+1	泪
+1	买来的时候还以为是纯粹的关于电影的书，结果读了才发现是融合了人类学和社会学来解读电影，所以也略微晦涩一些；已经习惯了电影的一切，读过此书之后，才发现电影的一切并不是理所应得，如果我们生活与从放映机到电影术到电影艺术的时代，一定会更加赞叹和感激电影的魅力。
+1	很有用啊！簡單清楚
+1	我的入门扫盲教材，图文并茂，最初正是被本书的编写体例所吸引
+1	耗时将近一个世纪，无数人死亡的大博弈最终在1907年通过外交方式解决。
+0	实在不好看啊！小三和一个长得不错又有钱的衣冠禽兽的故事而已~
+1	堡垒还是容易从内部攻克
+1	无政府主义的乌托邦幻想者
+0	怎么会有这样的书。
+0	惊呆了，我在看微微一笑很倾城吧，设定基本一模一样啊，弃了弃了……
+0	郝秀玉棒
+1	很好看
+0	百度百科
+1	后几章非常难，多方博弈
+1	戴爷。
+0	简直是开玩笑。
+1	通过这本书认识了不一样的伍迪·艾伦
+1	好一个塞林格~
+1	有意思的书，从另一面看电影的产生和黑泽明本人。以前一直疑惑为何芥川龙之介的竹林中电影版用的是另一个故事的名字，罗生门。原来背后有偶然因素，哈哈
+1	金作屋，玉为笼，车如流水马如龙。刘郎已恨蓬山远，况隔蓬山几万重。
+0	最后落入俗套...
+0	这小学生作文一般的流水账到底怎么得到7.7的评分的？！
+1	笑死我了，我爱你，普拉切特和克鲁利
+0	看着玩儿还行
+1	拿到手，一口气读完，好吧，早期的毛尖刚经历过暖洋洋的票友时代，对电影的热忱可谓真挚，对于电影迷来说，不啻为大餐。而后期的毛尖如今完全沦落为插科打诨，混圈子，互相吹捧的毛博士，去年的一本《乱来》实在令人嫌恶，再无半点好感。
+0	皎皎也就是这样了好吗，文风永远都是掉书袋系列，男女之间永远都是走人淡如菊风，矫情死星人。。。
+1	今敏导演真是一个可爱的人，制作电影那种事无巨细恨不得自己做完所有事情的状态真难得，缅怀。
+1	伟大的作品。
+1	半年才看完，不错
+1	对每个人而言，真正的职责只有一个：找到自我。然后在心中坚守其一生，全心全意，永不停息。所有其它的路都是不完整的，是人的逃避方式，是对大众理想的懦弱回归，是随波逐流，是对内心的恐惧。
+0	我觉得很难看··矫情地要命，初初看《守望灯塔》时的感受没了··
+1	寒假前在新图书馆的教室里看完的。很怀念。
+0	也看不下去的一部书，女主的那种刻意 孤勇，过于YY。
+0	一点都不喜欢，并没能提供多少实质性知识。这种科普类电影书还是去看《认识电影》更靠谱。
+0	本书完全可压缩为简短的十页有关历史简介
+0	这三本确定是同一个人写的？？？构思，人物刻画，文笔差了不是一点点，总结两个字：难看
+1	四平八稳的影评们
+1	内容不错，很实用。就是性价比不高，需要做这么大一本表格吗……
+0	一般！新闻流水账，入门级读物，罕有引发，缺少高论。看多了这些西方史学畅销���，觉得其实跟国内的历史故事书并无两般。
+1	《大而不倒》是一群因为次债危机焦头烂额的银行家，政府；《大空头》是一群因为次债危机大获全胜的怪人，一个事物，两个极端，世界太疯狂。
+1	潘帕，你让我说什么好呢。
+0	YY的过头了，女猪老强调她是乡下来的，但某些言行一点不像啊。为了残疾美男我勉强看了一半...
+0	挺一般的一本书。
+1	以史为鉴，可以明得失。国人学史必读。
+0	无趣
+0	盛名之下，難副其實。失望。
+0	为了虐而虐，情节好扯，我竟然看完了。
+0	情节牵强。
+1	前几天豆瓣推送，脑袋一热就下了单。68块大洋，希望书有所值
+1	所谓天才，的确是天赋与勤奋的集合，今敏再次佐证这个不变的真理；极度缺乏资金、人事关系危机重重的四面楚歌，今敏的描述依然充满趣味，各种形象的比喻让人忍俊不禁，也让我们找到些许他汪洋肆意的想象力之现实根源；看其创作灵感的涌现和之后修改，都非常受益，对其作品的认识也更深一层，特别喜欢第一章《遥远千年的呼唤》。
+1	入门 很有意思
+0	20170723。书评都在说人性，可是为何没有人发现汉尼的康复来源于黑暗魔法。为何要救助汉尼呢，天降神兵吗，好生不解。
+0	两星。穿越到三国，男主是曹操，生下了曹冲。这样好吗？
+0	阿治实在不该去碰鲁迅。
+1	我喜欢这个有理想的文化青年
+1	“与无可救药之地，疗人寂寞，是菩萨行”。
+1	终于读完了，非常震撼，美德的毁灭与世俗铺天盖地无可避免的堕落对比强烈，对现世也有非常强的反思意义。显克维奇是伟大作家，写你往何处去写尽基督徒美好，写十字军骑士写尽滥用信仰的可怕。
+0	看过的最为垃圾的一本旅行志 无病呻吟幼稚可笑毫无亮点 一个不入流的背包客写的看似深刻实则空洞的所谓文字
+0	给一星是因为没有负分可以打！剧情雷，文笔差，完全无可赞之处，不明为何那么垃圾的书能出版！同类型的故事很多，这是我看过的最烂的一部。
+0	从别的书摸过来的，微博上看几位作者应该关系不错。政治部分还不错读，言情部分就有点水平线下了。尤其是女主角神烦成这样也是好久没遇到过了。
+0	有讨厌的角，只快进挑主角的戏份
+0	2017的第一本书，赶在开年第一天的末尾看完了，书是从学校图书馆借的。 陈北尧和慕善的爱情，血腥又慈悲。张爱玲说，一座城沦陷了，为了成全他们的爱情。 假若现实里发生了类似的事，我大概会逃得越远越好吧。 喜欢庙里的那句话:一曲清溪一曲山，鸟飞鱼跃白云间。
+1	既畅想明日，更揭示今天。继午夜文库后又推出了幻象文库，爱死了新星出版社！
+1	死若樱花灿烂
+0	我已经过了看小言的年纪了 完全没有耐心看下去 而且还是带着神话 奇怪的文章 不值这个8.5分 开头看着还以为是耽美 只想说一句 你在逗我？
+0	不成立的故事。爱情不过是一种低等的情绪，最多也只是无聊的游戏。一个把爱情当作毕生追求的人实在荒唐愚蠢，居然还能被称作了不起，无法理解。
+0	终于看完了 通过这本书我发现原来一部作品的情节不是最重要的 字号大小和排版疏密才是决定看得舒不舒服的 这个作者用的字敢再小点吗 而且内容也是比较费脑的 真是让我看得比较累啊
+0	比较无聊的一本
+0	忍无可忍，无需再忍。
+1	历史与你 图文并茂 思考题设计的很好 不过最后几本政治倾向太强了些
+1	文字图片是真好，包括历史真实和采集经历，值得一读再读。可惜了这个做法，看来汉唐阳光hold不住画册。就算退一步，编辑也不合格，字体就不多说了，连译法体例的前后统一都没做到。为什么我要挑剔呢？一当然是职业病，二就是关注这个题材，希望书能够锦上添花，扩大影响。现在这个样子我都没法买来送人，只好让我爸自己去图书馆借了……
+0	我一直都在想为什么明明可以写得通俗易懂的话，扬之水总是写得云里雾里，让人昏昏欲睡？今天读这本书忽然明白了，这就是典型的「文笔不够，资料来凑」啊！
+1	想当年还是你推荐我读的，如今已经成了回忆。
+1	永生，男变女，设定的时髦值碉堡了。个人觉得这是伍尔夫最好的一本书，不像她别的作品一样晦涩，但风格依然如冰冷的火焰一般。这书是伍尔夫写给同性情人的思念，里面关于性别的心理描写很有意思。
+1	大三下 紀錄片創作課讀物。手册指南
+1	因为项目所以特别找了下关于以色列的书。从历史发展的角度相对比较深入了解析了以色列的“创业基因”，读完后对以色列的发展历程，以及军事，经济和文化都可以有一定程度的���解。
+0	一直都是喜欢她的书的，但是当全部的都是一样的基调，然后又缺乏了一些逻辑性，再喜欢也是会腻的。。这和东宫不一样之处就是那是女的死，这是男的死。。大同小异了。
+1	烧水时候站着看完的小说，想给六星。俄国的圣母崇拜致使他们小说里的女性是塑造得最丰富的形象。妓女和圣母、贞女和荡妇、贵夫人和情妇的张力造成无以伦比的艺术效果。在男主人公身上无可调和地冲突的复调，在她们身上奇异地融合。丽莎一转身就是Sonia.
+0	大失水准
+0	看完我觉得我应该去写小说，骗稿费。
+1	历史与哲学缠绕交错，历史变成了各种因素与巧合合力之物，可惜对于影像资料历史，知道的还太少。
+1	抗战期间，南渡；抗战结束，北归；又一次抗战结束，离别。说起来，简单的二十余字，过起来，却是很长的岁月，有煎熬，有无奈，更有太多辛酸。这是系列书的第二本，读起来依然让你觉得荡气回肠。不是文字有多么大的魅力，而是书中写到的人物以及他们的事迹，着实让你的觉得历史怎么可以如此厚重！上学时候，老师总在讲，由于历史原因，这样了那样了。其实，直到现在自己看了一些书，才知道原本很多历史可以改变，只是由于身处那个时代，太多无奈！假如当初国民党不那么腐败，执了政，当了权，中国的今天会不会更好一点？其实，哪里有那么多的如果！台湾的现在，多么的理想吗？其实，更遗憾的可悲的是那些大家，如果没有这样的北归，他们肯定会为我么创造更大的财富！可是，历史过去了。Now, 23:31, September 9th, 2016。
+0	新加的内容，就那么一丁点。有老版的同学不用买了，新的内容导读说的比作者写的还多，老版的错误与缺失，新版压根没订正。直接照搬
+0	太文艺。不喜欢。
+1	花样的年华，华丽的转身
+0	连仓央嘉措的诗都能弄错，只能说是为了装吧
+0	把这个作为盖棺之作实在是太残念了
+1	是枝萌大叔的日常与拍电影心得。文字虽然带有鸡汤味道，但讲的道理有太多共鸣点！
+0	低于2星。①5个独立小故事。②无聊。
+0	求放过！
+0	基本上没看懂，只是温习一下以前就明白的。
+1	很不错的博弈论入门书，条理很清楚
+0	太杂散，就像一篇一篇博客，书中太多日本特殊用语，翻译有点中文夹杂日文的感觉，
+1	很多《电影美学与心理学》已涉及。
+0	又臭又长的流水账 看完就记住一点 作者是哈佛毕业的。。。
+0	过于混乱，不知所云。并不反感飘渺梦幻的写法，但那也是建立在工整逻辑的基础上的，《务虚笔记》便是极好的案例。
+0	"慕名"读了一本“宅斗文”哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈所以就还是开上帝视角的玛丽苏女主嘛！！！！
+0	哦
+1	最爱2010
+0	在b站上看到这里的评分这么高，特意来打分的
+0	长得叫人读不下去，民国大师八卦谈，除了陈寅恪，对谁好像都有点揶揄。作者肯定特别爱看《水浒》，尽拿来做比喻。有一些事实，但从作者的识见出发不一定得出可信的结论。万卷出版的，错别字和体例问题很多，文字质量相当于盗版书。没事闲的也可看看，聊为一助。
+1	从古代以前说起~NB！
+1	好读！最喜欢《拉萨有铃铛》，有几篇前半部分读着感觉流俗了，后边笔锋一转，不觉泪目，就像《蝉的歌》最后几段想到了自己的朋友！不像一个94作家的笔触，推荐！
+1	《大地之柱》的原名比这狗屁的《圣殿春秋》强太多了。
+0	我淡比,居然看这种东西!
+0	冲着那些没品笑话加一颗星吧.
+1	生为女子。
+0	没有原因的特别不喜欢 看到和三公子在船上打召玉，实在捏着鼻子也看不下去了……
+0	书里的男性角色大概都可以去死一死了 不过最后却是女主死了 也挺爽的
+0	有点扯，而且好长啊，好没劲 呵呵 抄袭
+0	不会写情
+1	比较有意思的一个系列
+0	色彩，年轻的想象力和表现力，以及苍白
+1	有几篇那么亮眼，好久没看短篇小说了。
+0	看似有理，实则无用！
+1	群星闪耀
+1	看完后明白想做一名好演员那绝对不是一件容易的事情，那是要靠日积月累的排练 练习不断地向自己提问，替换，寻找人物的特点习惯，把自己自然的带入进角色里头。尊重！表演艺术！
+0	我竟然还看了40多章，没脸见人了！
+1	名家名著，一遍基本不太懂，已做好啃多遍的准备！
+1	萨拉马戈的眼泪，是医生妻子在盲人世界里，那双看得见的眼睛。
+1	由于这两天的际遇 看完这本书心中的痛楚缓缓释放 命运 征兆 迹象。19号晚上去看电影。 草蛇灰线 冰山下沉默的部分 突然握住温热坚定��手 你的拥抱 以及最后的不告而别 仓促收场 目光是尖锐的 为何如今你我不交一言 有一天还会再相逢吗 那时候我会是你期冀的模样吗 “她对接下来的变故浑然不觉，毫无预见，一切也没有征兆。”“一切早已铸就，往昔从未离她而去。” 作为一个花痴 我只服这本书的阐释
+1	真实到可怕。尤其是各种内心情绪的细腻的描摹~简直是让人怀疑这真的是男人写的么？他怎么那么懂女人的心呢。以及感觉看到了自己以后生活的全部~
+1	连续五个小时的阅读，大脑像失控的转盘飞速转动，却是机械地转，绞动思维又茫然混沌，理不出清晰思路，最后只能定为一场疯子的臆想。
+1	金仙观之谜和离合诗之谜依然没有揭开……第四部呢？第四部呢？第四部呢？
+1	也忘了。
+1	看见伍迪就忍不住买了。从创作者角度重新看待伍迪的电影，这本书给了人们这样的机会；书中没有多少八卦和伍迪在电影之外的生平记述，但要比那部纪录片更实在。
+1	近距离观察大师们的思想和生活，体验大师们的人格魅力
+1	对于我这类经济学白痴逻辑学优秀生来说，不错。
+0	眼睛都快看瞎了，只想快点结束，，，事实证明浪费时间浪费眼力读一本没有价值的书
+1	第一次看香港推理，没想到意外的好看。
+0	我tm再信豆瓣推荐，花钱买这种书，我真得剁手了，气死我了
+0	首先真的不好看啊，都是第一人称一直在bbbbbbbbbbbbbb，除了结尾稍微能勾起一点情绪波动，其余时间的阅读都是对读者的折磨。其次不管原文怎么样，翻译是不好的。比如作品中很多吃穿用度用词已经进入汉语，译者本地化得不够彻底，显得很生硬。
+0	政治倾向很重。立场不客观。考据多为野史，可信度质疑。文笔有很多主观色彩。和史记比比简直天上地下
+0	不要把400千字的时间浪费在这本书上
+1	大历史里的小人物，却也是不屈不挠得另人敬仰
+1	简直五体投地
+1	很多现在看来是理所当然的，其实是经过一代人的牺牲（事业甚至生命）才得来的。
+1	《一個隱形人的畫像》 very impressive
+0	《活着》五星，《许三观卖血记》四星半，《兄弟》四星，……《第七天》两星
+1	六六折开卖
+0	又出厕纸了？
+1	喜欢这种絮絮叨叨的聊天 不用在乎现实 自由的对话
+1	赤贫的孩子成长的故事
+0	能再烂点吗？
+1	可以一下午看完的编剧入门书，中文版有关键词汇的英文翻译，很好用
+0	实在好讨厌这种当年席娟腔的语气写游记，赚点小便宜就很开心，觉得自己聪明伶俐古灵精怪一样。
+0	很一般的高干文，翻过就忘了
+1	这真的是一个很棒的故事！
+1	我是看的电子书，几天就把这四本扫完了，视力硬生生下降了好多，看来以后还是看纸质书适合我。虽说其中有两本写作年代久远，但作者的想象力到今天看来仍不过时。人类从哪儿来，要到哪儿去，希望就象书中写的那样吧。如果说阅读的快感，我还更喜欢刘慈欣的《三体》呢！真的有一个高度的文明，留下一个机器就能改变一个星球上的生物的进化历程？真的能想摧毁就能摧毁一切？就象人类对于蚂蚁，这个文明对于人类也是高高在上。太操心了，还是过一只蚂蚁愉快的生活吧。
+0	弃文了，书中有乐谱~
+0	完全地，圈钱
+1	小津的散文与电影风格一致，简洁、质朴，保留日常生活的原貌，在无意中发现美。信的画面感很强，像分镜剧本。如果那田野里鲜红的彼岸花、秋天城外连绵的麦田、战场上纷飞的白色杏花，都不是侵略中国时看到的，就更好了。翻译是亮点，十分怀疑译者是学中国古典文学的。
+1	苦难并不是一无是处。
+0	读了五分之一
+0	平铺直述，实则波流暗涌，结婚、误会、送回江南、误会、怀孕、误会、受伤、生产、冷淡、怀孕误会、逃离、三年后重逢，北地血性男儿与江南温婉小姐，民国乱世绝恋。
+1	超级不喜欢过于长和仅仅只是介绍往后会在书的本体中看到的内容，读什么都在读之前被剧透了，还哪里来的新鲜感？！我想看的是内容不是那个长到十几页而又空泛泛的前言！！！！！！感想你就他妈的放到最后不行吗？一开始就从第一章介绍到了最后感谢人员名单你让我看啥！
+0	張祖畫說 覺得一看東野的書 就好捨不得。突然發現我已經好久好久沒看東野圭吾了。感覺讀「白夜行」已經是上輩子的事。如果沒記錯的話 這本應該是東野大神的出道作品。看完之後也確實感受到了這本處女作的青澀之處。也才剛看完 就已經對錯綜複雜的關係網和人物名記不清了。東野圭吾的底牌永遠不會讓你失望。最精彩的不是殺人手法 而是殺人動機。可惜我在看書之前就已經知道殺人動機是甚麼了... 因為自慰被老師看見而殺老師... 唉 讓我說甚麼好...
+1	没想象中好。不过家书能写成如此风采已是难得。颇有知识分子的清高劲，话大多俏皮，但某些针对“未开蒙”民众的话读来膈得慌。 不从土地中来的学人大抵都是这样，文字厉害精彩，思想也精细，但偏偏少了让人亲近的乡土气。不如邓晓芒。
+1	太好看。书评在日记。
+1	潜龙在渊
+1	因为有周振鹤老师这样的学者，难得地觉得我蛋还是挺不错的
+0	好吧，那个电视剧很恶心，我居然看完了，这书写的更次了，我竟然也翻完了
+0	2.8分
+1	“对于某种优越的身份依依不舍，其实就成了不平等的捍卫者。”
+0	望天，不是一般得烂好伐，作者已经YY到一定境界= =
+0	我实在是写作课看得很痛苦想看看中文版，但这个翻译真是过分到谷歌翻译都比它精确翔实了……译者只要不会翻译的，就会说“XX来着”，很怀疑怎么找到这么个人的。
+0	只有我觉得这本说写的很差吗？？？？
+1	好美的小说，要去看看电影
+1	影评人辞典
+1	不能永远憎恨 但绝对不能忘记
+1	就是我想要的思路，当然知识层面和结构要更新，但打通各学科是必然的
+0	非常狗血的一部书，但是坚持看完了，真的狗血到不行，好么？竟然还有第二部
+1	很难评价的一本书，看了很久，挺难读，但最后有种终于释放的感觉，心理治疗真是对心理咨询师和患者的双重折磨。
+0	我曰尼玛，终于读完了！！
+0	left2，安东尼2.0。当然咯，一定会有粉丝买账的啦。
+0	就是几篇论文的合集，有独特观点，就是没什么太大的说服力！
+0	我的大部分半途而废的书是因为读的艰涩，觉得智商有限。这本书半途而废是真心觉得无聊。爱情，不是给你几个青春荷尔蒙时期的故事就能讲清的，看过霍乱时期的爱情再看这个实在是入不了眼。
+1	作者多年关注小津的研究，积累了丰富翔实的史料，写作本书仍然没有信手拈来之感，而是亦步亦趋。尝试了用各种角度对小津进行观察，在表达观点时仍然相当节制，令人敬佩。但编辑和翻译方面似乎略有问题。
+1	从安乙家拿来的书。慢慢地看了一年。怀念那一些行走的日子。和死过去的时间。
+0	烂。即使是村上君，我也不得不说
+0	不好看！一点都没意思，到最后是几分钟跳着看完的，一点都没有看的欲望
+1	断断续续的读完了这本书。它太好读了，任何时候打开都会很快陷进去。可它也太可怕，它对于人物心理的描写是真实到残酷的，不需要过渡和转换，你就能进入到人物的内心。平淡的故事下一个女人对于家庭的所有眷恋，和亲情复杂的纹理你都能摸透。很佩服作者的功力。
+0	慕残天雷
+1	永劫回归。你喜爱这个想法或憎恶它？以你喜爱它的方式来生活吧。……毫无疑问地成为人生最爱的书之一。
+1	全彩印刷很赞, 很好地表现了书中的电影画面. 每一章都是一位电影摄影师的讲座, 介绍示例中的问题和解决方法非常实际. 当然, 这也意味着, 有一定影视摄制/道具灯光等等相关领域基础知识的人阅读此书可能会更有收获.
+0	“从事写文章这一作业，首先要确认自己同周遭事物之间的距离，所   需要的不是感性，而是尺度。”（《心情愉悦有何不好》1936年）
+1	无神论者的坟墓
+0	要说实话么？真的要说实话么？会不会被为数众多的三体粉撕成碎片？首先作为一个文科生对科幻方面没有吐槽资格这个自知之明我是有的。各类科普式的剧情展开很开眼界？特别是最后曝露三体文明真相那个地方，但是容我吐槽一句，好歹是个小说不是科普类书籍，一下子情节量都在那里爆发了感觉好2333啊。就像以前有人吐槽FFXIII一样——世界观是如此的宏大，你他妈在游戏里体现出来啊！世界观资料全放文字资料里你做个毛线游戏！←这种感觉。然后小说方面剧情衔接什么的各种硬伤。最最最让我想吐槽的是那“人类文明是如此无药可救→这种烂文明毁掉吧”这种说不清是圣母还是救世主还是中二病的思想，在小说中用来做人物的动机哈哈哈，真是看着各种神棍啊。后记里还提到道德！大大别这样！你写自然科学科普吧！不要染指人文！简直就是槽点批量生产机！
+0	。。。看了一半。受不了文笔太渣= =。完全不会描写人物对话不会好好写记叙文的作者= =。。嘛总之就是女主不知道为什么就傍上了一个钻石王老五而且那个钻石王老五在没有和女生做出什么事情的时候就喜欢上了她= =。。两星半。。。
+0	这书可读性极差，居然有这么高的评价，真心给跪了，豆瓣不可信
+1	���人
+1	力荐！
+0	难看到爆，有这时间还不如再看一遍全球通史！
+0	哦，我的上帝，我发誓，这碗鸡汤的翻译实在是糟糕透了！
+1	宏观决策，只看了前半部分
+1	两小时读完 理性务实
+1	好多看不懂。
+0	无法代人，没有情怀。
+0	我实在欣赏太宰治老师不能，迅哥也能被你写成如此矫情姿态。
+1	按图索骥，找了好几部没看过的电影看了，确实不错。不懂电影学术，但作者是真心爱电影的人。
+0	比较适合我现在的心情。这本书已经买了快两年，现在拿起来继续读可谓是天时。戈列格里斯做了他内心不安时常做的事：打开一本书。在重新拿起来三天后，读到接近二分之一，读不下去了。反复的咀嚼后，对男主最后的人生选择已经没有兴趣，因为，可以把具有时代意义的事情叙述得如此无趣，也可以合上书了。
+1	（P）被猪油糊了眼的中国影民万岁，这故事完全没意思
+0	不太适合我，这位的电影也不适合我。仅此而已
+0	不知道为什么评价高
+0	好闷！看不下去，读着就睡着了！
+0	很糟糕的一本书，占主要篇幅的都是对实验的描述，但是对结论的深层分析（心理、经济等），还有现实生活中例子的引申的却一笔带过了。盛名之下，其实难副。这本书太肤浅了。稍微让我感动一点的例子是社会规范和经济规范的碰撞。“一旦社会规范和市场规范发生碰撞，社会规范就会退出。换言之，社会规范很难重建。”这让我想到了文革，现在确实很难再重建社会规范了。但是我始终相信每个中国人都流的有儒家的血脉。虽然儒家式微，但是星星之火可以燎原。就像日本二战后道德体系崩溃，全民滑入拜金主义思潮。但是等到经济恢复后，传统的一些道德规范和民族性格又跟新社会形式相结合，慢慢复活。这是民族文化的根。
+0	需要认真地怀疑豆瓣有水军了。
+0	为什么评分如此之高，让我好生失望，一直吊着我的口味，这种感觉很讨厌，最后也没什么特别出彩的地方，有种强行文艺的感觉。
+0	爱得莫名其妙？？？喵喵喵？？？有点做作
+0	還行吧，足夠為自己的不環保行為去找借口。
+0	矫情。但还是说一句。相恋是两个人的天长地久，相思是一个人的地老天荒。
+1	相当有趣！
+0	我曾一度看完序之后以为这位作者品位真好，但是读完两章后发现历史还是历史，作者写得真的很烂，读起来很难受。有种砸了BBC招牌的感觉，但是BBC也不是每一部记录片都是高分。
+0	不好看。情节真的太狗血了。
+0	鸡汤
+0	淡老师说：这本《乱时候，穷时候》描写的中国平民的生活，可以总结成：相互坑，使劲生，窝里斗，欺负人，恶狠狠，特兴奋。那是真有精神头儿。 ——就是这样。
+0	全篇通读了一遍，这么多打五分的都看过书么，完全就是过誉。这年头还有书托了。
+1	虽然我没做过党的书记，但是为啥这么感同身受捏？或许像瞿秋白一样，我一直向往与熟悉的，也是一种文人式的生活。虽然“一为文人，便不足观”，但文人还是做文人擅长的事情吧，不要勉强自己去开会写报告假装历史开创者了。瞿秋白的经历真是历史的误会，各种机缘巧合，一个想去北大中文系好好读书的文艺青年就这么走上了革命的道路。被架在政治的高位上下不来，那种感觉真不好受。临死之前，遗书写个差不多了，瞿秋白做的最后两件事是：推荐了几本值得看的书，感慨了一句“中国的豆腐是顶好吃的，世界第一”。
+1	从新的角度看反垄断的出发点和结果
+0	两星不能再多了。都说现在游记水平参差不齐，这本就是就是拖后腿的。两星给前半部分日料，后面的流水账看完有种被骗的感觉。看了短评发现是作者和熟人的自娱自乐，仅仅一百多人刷出的8.2分真心指导性不大。现在出书的门槛都这么低了么。
+1	虽然是英国作家，但是是讲希腊的故事。现在对希腊产生了强烈的兴趣。 书还是很好看的，尤其是看完了天使望故乡这本没有太多drama的所谓小说之后再看这一本。然而天使的作者沃尔夫明显感觉比希思罗普的文笔要好。后者在岛里讲故事的能力不是很强，故事节奏不是很好，不知道是不是中译本有删节的缘故。  但是故事还是很吸引人的，花了一天半读完，除了韩寒的小说和期末的考试突击数学，很少有突击一两天读完一本书的经历。  总的来说，瑕不掩瑜吧，是一本感人至深，让人产生时间的洪流和人生多艰感慨的好书。
+0	看不下去，一个简单的观点不断重复。 分明一段话就能解释清楚的东西，写两页。
+1	山东--临沂--蒙阴路上的阅读
+0	这难道不是盗墓笔记吗！！！
+1	的确翻译的不怎么样。
+1	好书推荐
+0	好像比上一本读来更通顺，没啥意思有点浪费时间。作者好像特别擅长景物描写，能想象得见非常美。
+1	当得起"Masterpieces"这个书名。
+1	很幽默风趣的一本书，很喜欢
+1	翻译得不错，但是原作的前两章写得实在枯燥，坚持下来的人才能读到最后。
+1	塞林格~~~~~太心水了~~~~~
+1	几度热泪盈眶= = 梦想家的时代
+1	谁写的内容简介…真见鬼  叹
+0	很大程度上是翻译问题。
+1	大胡子的最后一本书，一个星期读完，这个美国老人的朝圣之旅令人赞叹又汗颜
+1	不存在既存在~可我仍不明白其中的真意~看来需要多读几遍~
+0	只能给两星，南天门打了仗回来就开始罗里吧嗦的讲，除了战争真的没法看，啰嗦而且立意不明，如果是想表示反战我的确看不懂整篇罗里吧嗦的说些什么鬼东西。感觉能删一半
+0	最后的小说还挺有爱的
+0	天雷！
+1	果真是拿起来就放不下的一本书，故事情节扣人心弦，跌宕起伏。让我所读的都相形失色，问题的关键是作者高罗佩竟然是个荷兰人！！！感觉自己都不是中国人了😳😳
+1	趋势总是在变化，我们需要找到最根本的东西！历史总会给我些启示
+0	虽然衩姐很好，但这本书的评论也太虚高了
+0	#论有些言情直接给一星就好啦# 拉低逼格系列之各种奇葩写手 30=v= P.S. 对 我是真的看过
+1	纯净的、善良的“我的朋友”。世间唯有一种罪不能被原谅，那就是故意的残忍～
+1	直到80年代去美国访学，吴才真正接触到了西方经济学，那时他已经50多岁。这一代经济学家的观点主要来自于多年来的亲身体验，肉眼观察，没多少学术成分——因此吴主张求稳、求实际，成为了“改良主义者”，与现在中央决策者中的主流观点一致。
+1	正在读～
+0	天雷！
+0	怎么说呢。。。。相当鸡肋的一本书。。。= = 闪光点不是没有~可是。。。情节还能更老套些吗？世界观还能更陈腐些吗？
+1	很多很多对话，有些看似不知所云的nonsense，不过我真心喜欢这两个有所关联的中短篇小说。过段时间重读之后要静下心来写篇书评。
+1	除了德勒兹和福柯外，其他几位的不用看也行
+1	看的日文版，例子几乎没看————这真的是本科教材吗好可怕wwww
+1	不错的书，很实用，分解的很详细
+1	可以用来指导影视赏析，也可以用来观察人生。（得）
+0	需要慢慢品味去理解！
+1	正如封面所标榜的那样，丹布朗式的巨著，小说的感觉强了点，分析和介绍整个危机的来龙去脉少了点，不过仍不失为一本关于次贷危机的好书。
+0	故事编排有点杂乱，快速读完，无感，可能期望太高。
+0	这绝对不是一本合格的游记或者日记，偏向于作者喃喃自语，文笔欠奉，关于羌塘也没有什么特别的理解，这算啥风格？BBS意识流集结文？这样的超高分评论还说都是喷子，真是醉了。。也许是不认识这位大侠的关系因而无法理解，他人品分也许很高。。PS.有些段落的心理描写也还不错。但重复也太多了。
+1	黄色封面好评。Les Matins gris de la tolérance --- 是挺难翻的。
+0	比尔布莱森他用一贯的幽默带着我在澳大利亚走了一圈儿，将旅途中的趣事和这个国家的历史一股脑都倒给我。无奈上海译文的这几个翻译水平太差，已经影响到了阅读，达到令人发指的地步！
+1	王小帅 骆以军 黄丽群 陈雪 小野 联袂推荐 华语世界实力名家力荐 新生代写作者中头角峥嵘的一支笔 第六届华文世界电影小说奖首奖得主胡迁 迷人、离奇、惊奇、爆裂、令人惊叹的中短篇小说集
+1	真是好久都没看过这么好看的小说了...
+1	送给最喜欢的人的童年
+0	我要是再看穿越就不是人。
+1	耶鲁公开课里面好像都讲到了这些
+0	水合靠<五蠹>一站成名，但是其他文太令人失望了。
+1	提纲挈领
+0	并不懂豆瓣的评分，感觉好表面，生搬硬套挪来的文字。不如三毛的撒哈拉写的有趣生动。就像是到别人家做客，你觉得你看到了一切，其实也就是你看到的那么一瞬间，但眼睛看到的未必是真实的，你以为的只是你的短暂一瞥，太不深刻，不建议大家购买。。。朋友推荐了夜航西飞，听说很不错，打算入了。
+1	德勒兹在最后说哲学是干出来的，他就是在用哲学概念的实践来做出一种电影理论，它不是关于电影的理论，因为理论无法取代实践的电影本身，他的抱负是在创造出尽可能多的事物-物件-存在理论，由一通万的理论，万万相透的拓扑理论，他的理论是一座迷宫，不是没有出路，但是遗落的线头一如历史般千头万绪。
+0	老生常谈
+1	为了写期末论文匆匆翻过，还真是本好书��！但就是没有我的论述角度╮(╯▽╰)╭
+1	实话实说，不喜欢前半部分，喜欢后半部分
+0	吐了
+1	在封闭空间的小团体内，最丑陋的和最可怕的人性都暴露出来，不再拥有道德和文明。在世界朝着不可预测的方向毁灭之时，萨拉马戈却给了故事一个急刹车——一个荒谬绝伦的收笔。
+0	给六岁孩子看差不多
+1	正义必胜的佳作
+1	大师写大师这么难得了，更何况是安东尼奥尼和文德斯。序和译后也很得我心啊。要把云上的日子再翻出来看看。
+0	太小白的文果然读不下去，努力到了最后几十页终于放弃了，秒了结局，收摊，over!
+0	不喜欢这个类型。以为是恐怖的才看的，但感觉主要的是言情，恐怖的部分也不吓人
+0	忘川，又见忘川，能不能有点创意啊，不失忆会死啊，我真没觉得哪里虐了，虐文才不是这样的，撑死了还是篇狗血文，要不是这是篇古代文没准我就打两星了，我本来还以为古代文怎么样都还能有冷月如霜的水准，匪我思存不愧是狗血文作者的先驱啊
+0	我觉得这个写法还不错，我跳着看觉得老了的玫瑰比较可爱，不过我实在觉得此女对人生甚部负责，年轻时完全就是为非作歹。另，我好喜欢苏更生这个名字。
+0	阴谋是有的，不过不可能下这么大的棋。二战后通货膨胀加速倒是事实
+1	我就知道我们的情绪有重叠
+0	呃，主角弱智到我认为是作者脑子有问题。其实挺不错的一个题材，不过作者写文时，脑子不知道跑哪去了。
+0	采用技术分析非常危险，因为历史股价对未来股价没有参考价值，股票市场也不存在趋势。
+1	以六篇中篇小说为基础，叙述了香港67年到13年..前四篇推理很赞，最后一篇的叙述手法意想不到
+1	开山鼻祖哎
+0	在白云機場猶豫了4個小時還是沒買...PDF版看得我希望自己看到的是网友写的版本。
+1	爱上尼采啦！
+1	详实历史背景与拉片技术分析，构图调度，长镜头与固定机位，沈从文朱天文与巴赞小津，浮云连缀的电影与文化的中间地带，用“台湾经验”解释侯孝贤的“中国性”。
+0	勉强看了百分之八实在看不下去了 太墨迹了
+1	对老五更感兴趣，确实写得好。
+0	第一本扣人心弦，第二本开始啰嗦，第三本是用400页讲了一句话的故事。感觉头起的野心太大，最后气接不上了。
+0	先告诉我这是设定集而不是小说可以吗。科幻小说卖设定和推理小说卖诡计一样的，看完让读者感到自己智力值level up了可以鄙视没看过这本书的人就可以了。嘻。anyway，你们开心就好咯
+0	道理我懂了 但能不能好好说话?
+1	以前贵金属时代，中国的利率都是很高的，几乎都在100%以上，货币紧缺
+1	那篇演讲真不错
+0	两星半，真是……又矫情又作
+0	2005年4月2日 天津。谢谢ZY
+0	专业术语都是跳着过，其余的文笔又有点差
+1	飞机上读完，有几篇催泪。
+0	大纲式的流水账。
+1	比电影好看。会说故事的人。
+1	作者的工科教育背景，使得他们得以从系统论和控制论的角度，全面剖析传统中国千百年来大一统格局的历史演变背后的深层次原因和奥秘。作者对中国政治、历史、文化的综合分析能力和开阔的学术研究视野让人叹服。在改革开放之后中国文科学人的学术性著作里，本书的原创性和开拓性也是首屈一指的。
+1	内容翔实 非常有趣。|||断断续续三天读完了。强烈推荐！Implications：固步自封与世隔绝只能导致落后和愚昧 这对个人也成立 因此一定要保持与世界的同步；如果书中描述属实 十八九世纪的中国实在是面目可憎 简直让我政治不正确地认为的确需要一些来自外部的改造；但是因为一个国家或民族落后愚昧别的所谓先进国就有权利去征服它了吗？一个国家是否有落后愚昧的权利？我没有得出答案 因为就现在而言我认为最落后愚昧的国家之一就是朝鲜了而我着实很希望美国去打掉金胖的家族企业；的确直到今天中国的知识分子仍沉浸在天朝上国的莫名其妙优越感中 这点我自己也要反省。以前我完全没意识到马葛尔尼来中国的那年暴发了法国大革命 作者经常会插入叙述某事件发生时西方同时进行的事件 这种描述方式我非常喜欢。
+1	都是大实话 或许好好遵守可以保证骨架不倒
+1	地图的制图史，其实也是人类对世界认知过程，也反映了政治中心、传播媒介等的变迁，角度很棒，从中了解了很多之前没有注意到的关联，尤其是我们今日明天面对的地图形式，其实只是近两三百年的产物，着实让我震惊。本书缺点：大量的彩页地图插图，有标号，但在正文中却没有索引
+1	N年前中学时看的书，好怀旧~
+1	随意的生活和电影的组合
+0	任何时候，极端分子我都挺讨厌，就算他站在我这边。。因为他不可能永远站在我这边
+0	不及电子版。编辑去屎。
+1	嘛嘛，言情部分乏善可陈，就当历史小说看噜w
+0	不喜欢，读了1/3就读不下去了。感觉好无聊，一件事情可以讲10张纸，没耐心了都。
+1	帮我搞清楚了城市化过程中农村土地的问题。很好懂。。
+1	既有精彩的故事，又有旖丽的文字，读起来觉得身轻如燕。
+0	开头还不错，让我大赞她对新风格的尝试和开拓进取精神。再往后看，发现不过是狗血情节大拼盘。这也大概是言情文的套路：女主必受诸多男主的追捧；深情男主仿佛跟踪狂，了解女主生活的细枝末节，又时不时在女主身边现身嘘寒问暖；可关键时候可能又智商全无的找不到女主，多少年后重逢，不是HE就是沧海桑田。
+0	文很一般，但是谈书墨实在是极品
+0	不喜欢女主，大事上不分是非，小事上锱铢必较
+1	名字很文艺抽象，故事却是一部推理小说
+1	吴晓波的叙述风格，把人物置于历史大背景之下。
+1	这本我倒是很喜欢，后半截泼狗血的地方也看得很爽！嗯，果然悬疑是很重要的啊……不对，其实这个女主角我很喜欢，她总让我想起某个温柔沉默的同学。
+1	有借鉴意义
+0	笔风清丽，但是文风更显孤单，孤单到有消极的味道，反而并没有觉得的一个人的世界更美好
+0	书名抄袭 不读也爽快给一星
+1	太有学习价值了
+0	瞎鸡巴书！
+0	太一般 没看完
+1	可读性强，故事切入点也抓的好，难为作者还花心思构思了若干女性角色。要再回头去重读《明朝那些事》对比一下大势，可能会对人物有更深的理解。
+1	正如书名，我怕没有机会，选择真正喜欢的生活。发现笔者的想法跟自己好像，也许非常有欲望看这本书的人，都有相同的看法。羡慕笔者可以在对的时间遇见鱼自己频率相同的人。
+0	书太粗线条了，要是没有这段历史的基础，根本就没法读，要是有这段历史的基础的话，也就没有再读他的必要了，还有就是中信出版社的典型毛病——装帧精美（我就是看到封皮才决定买的），翻译垃圾，句法不通，读的很累，并且有错误，本书为数不多的价值就是书前的地图和书后的皇帝列表，可惜列表还有错误（君士坦丁三世生君士坦丁二世，君士坦丁二世生君士坦丁四世），无语吧😄。同系列的还有两本，维京传奇和诺曼风云，也不想读了，耽误时间。
+1	旅行不是在田径场里比赛，看谁更高更快更强，而是在超市里购物，每个人都能拿到自己喜欢的东西。
+0	我觉得很囧，所以弃文了╮(╯_╰)╭
+0	作者只想着磨字数赚钱了，吃相难看
+0	还可以吧，8.8不是水军刷出来的难以相信啊
+0	很台言范，读来很省心轻松，虽有阴谋波折，但最终肯定会是happy ending，长度适中，比较利于放松，文笔还ok。
+1	看完电影再看小说 真的觉得小说是神作了
+0	人物怎么就失控了
+0	纯粹是肤浅的事实罗列，分析既不深入也不专业，论证也不严密，漏洞百出。如果作为一本娱乐书籍，还是有价值的。
+0	呵呵
+1	一口气看了下来，知道了我喜欢的电影的创作过程后，真的十分佩服和感动，以写出好的故事为目标，全心全力地前进。
+1	作者爱看电影的理由 和我一样 有些看电影和认识的观点很新颖 应该是一个热爱生活 电影的人 你一定会在这本书里找的你喜欢的 如果你也爱看电影的话
+0	看一章。齐。
+1	图例片例相当多 很细致 不过显得有些啰嗦
+0	一个垃圾的翻译会毁掉一本书
+1	作为一本传记、随笔也是很好的，抛开电影而论。
+1	无疑是看过的最好的奥斯特，我甚至可以百分百肯定奥斯特的老爹是天秤男……
+0	二星，文章写了三分之二，男一和男二还没碰上，刚打算弃文，又碰上了。男一的身世也就算了，后来莫名给女主加了个身份。最后五分之一实在没法坚持，弃了。不过瞄了一眼结局，又被炸了一下。
+0	小说最重要是讲好玩的故事好吗？形式大于内容
+0	我觉得不好看，电视剧也奇丑。
+0	太矫情了...没什么意思，脑子一热才买了
+1	以前看兄弟连的时候，看到战场上一大兵居然在看这本书。我想那个时刻他一定会忘记了硝烟和枪声。
+0	本来是因为关注了微博才在第一时间买的书。很失望。圈钱的书。作为网页上的旅行攻略也勉强算是凑活，作为书，作为建筑师，真是浪费名声了。
+0	读书最烦两件事，一是絮叨，二是卖弄。这本全赶上了。
+1	第一次读完弗兰妮，祖伊没读进去，昨天今天读完了。
+1	挺实用的，虽然教授的内容论数量不多，但好就好在能够通过几个结合了实际操作的小事例激活自己脑海里在其他相关书目中所获得的纯理论知识。像是起到了某种催化剂的作用。稍有遗憾就是如果书中教授的事例再多一些，充分一些就好了。第八章拆析剧本读过后仿佛真有老师给你上了一课。
+1	从“八月政变”到1991年12月戈尔巴乔夫发表退职演说之间那段时间，是真正改变苏联命运和世界面貌的五个月。
+1	大师写大师，值得读读。若非托宾，我还不知敬爱的亨利·詹姆斯是gay.
+0	承认你的好看，但痛恨你的抄袭,最垃圾的还是你的死不认账！特么跟安倍狗有什么区别！
+0	乱写的
+1	尼玛的长死了- =
+0	作者边走边记录沿途感悟，杂乱零碎，加上翻译差，实在看不下去
+0	女权毒，所有便宜女主都占了，却整不清她何德何能。所有男角都无私奉献，博取女性受众的妄想，即便是言情小说，还是想抓作者大力摇晃叫她醒醒。
+0	屎！！！！！mb还敢给我推荐！！！！！！不看见了还不恶心，就是一坨屎！！！！！！！！！！二十几大元！！！！吃一坨屎也比这强！！！啊！！！！大头救命啊！！！！
+0	烂校对+烂插图+烂排版=化金成泥
+0	虽然比较散碎，但还是很有意思的!
+1	为啥我看到谁谁谁留在了大陆，就想到这人之后肯定很惨。这本书让我看到那个时代的许多无赖，也让我看到了真正的大师。
+1	应该是今年最后一本了。
+0	玛丽苏
+1	仰慕作者啊，可惜死掉了。
+1	太好看了吧！！！强烈推荐啊！
+0	翻译不好，内容也不见得如何。
+1	硬货！对于电影爱好者来说很开脑洞长知识，但是有点过于专业。
+0	本来不想有失公允地评分，但是今天唐七居然否认抄袭我实在太气愤了，我要把她所有出版书和衍生作品打一星
+0	我其实就是脑补窦骁了一下 一般般吧
+0	应该不是韩父代笔吧，如果一个中年人写出这么一本书，那水平也太渣了。2星。
+1	这三本看完用了两个多月。这也让出版，，，大师远去再无大师。。。把XX说得像五胡乱华。。。
+0	为什么一本天雷清穿玛丽苏会被捧这么高？
+1	很早之前看过的书，让我对这位导演有了更进一步的了解。听他慢慢讲的那些事一段时间很鼓舞我。。。对这条路隐约觉得不容易但内心充满希望。
+1	引人入胜的情节，意味深长的结尾。
+1	伟大的写作是双性同体的（打印着读的  ）
+0	翻了两页就读不下去了，内容完全和豆瓣简介不符！！虽然名字就已经暴露了其实就是个口水鸡汤，然而简介却误导我以为是什么经济学社科……
+0	读到一半，才觉得有意思。
+1	NEMO推荐
+0	读完发现读读雪球版导读就够了，并且只需要读其中“学经济家”的那部分就行了。当然，像我这种事先不知道非要读一下全本，当成故事会读读也无可厚非（当然里面也会有不错的知识点，只是我现在对于这类宏观理论直接无视了）。最后，行天丰雄补写的东西，让我觉得我们人行目前的所作所为都是对的啊，比如供给侧、去产能、国企混改、地方政府财政强化、反腐败，他说的我们基本全做了。当然，结局如何，慢慢边走边看吧。
+1	记得前一阵贵鞋说起这本作品的时候吐槽了一下动机，结合终章的话我倒觉得挺合情合理。逻辑推演非常不错，相当本格的作品啊。
+0	这本要看
+1	“陀思妥耶夫斯基是我有所受益的唯一的心理学家：他属于我生命中最美好的幸事之列，甚至超过了对司汤达的发现。这个深刻的人——他十分正确地对肤浅的德国人采取了鄙视的态度……”——尼采
+0	雷点丛生啊
+1	除了小武剧本还收录了贾樟柯之前的一部短片剧本，包括一些的采访和文章，有干货，很受教。
+1	很期待
+0	桐华没有塑造令人印象深刻的人物的能力，这是我看不下去她小说的一个重要原因
+0	看到这种书就烦，一丝都没有经济学该有的严谨和审慎
+0	在写教材么？
+1	我喜欢黑暗系的故事！
+0	不是很喜欢，我讨厌这种不疼不痒的书
+1	感觉漓江出版社的这个系列做得很认真。
+0	我一直深信宋鸿兵是地摊文学的搬运工，如果他所言的银行家背地里有这么一套，他写了这么多大卖的货币战争，估计早就被银行家搞死了。还会出现站台被打事件吗
+0	30%弃了
+1	辛老师在本书中的四个字足以概括其才华与气魄：后出转精。
+1	看错了了书，借了最初的版本，离考试还剩十天的时候在八楼南发现了这一本，天注定。
+1	做豆腐的人去做咖喱饭或炸猪排，不可能好吃。
+1	把我的灯拿来
+1	还记得这本书是从一位研究生学长处借过来读的
+0	整本书以观点罗列为主，逻辑问题太多
+0	APP看的，目录好像是对不上，，难道有错���= -，因为这爱的作的折腾的实在莫名其妙啊
+0	看到她的天使投资老爸投给她40万开旅馆后，我的梦就不再做下去了。
+0	不明觉厉
+1	流畅翔实，但也有些平庸。4.5，立场好像略微偏共
+1	没有想象的好看
+1	前半冗长，后半颇可观。
+0	尝试看了2遍 都弃了。。。
+1	雨果
+0	这么幼稚，玛丽苏，小白，没逻辑的小学生作品我是怎么忍受下去得呢？
+0	逻辑恐怖
+0	抄袭零分抄袭bl负分
+0	像是一本博客的合集，其中一部分章节写的还不错
+0	看过簪中录之后，试着看了侧侧轻寒的其他小说~~可以说都不是特别喜欢，特别是这一本~~我真的是以便鼓励自己一边看完的~脑残偶像剧情节太重了~~完全感觉不出和写簪中录的大大是同一个人！！！总之，非常失望！
+1	2017重读，挤掉水分很有用，就是太美国了
+1	从1996年到2008年，这个人对于电影的敬畏和热情好像一直都没有变过。他说，电影是他接近自由的一种方式。喜欢封面选的这张照片，看完书，就觉得贾樟柯平时做的最多的动作可能就是这个。
+0	这样的书，骂什么脏字都不为过。明年诺奖还不是你的！凑表脸！
+0	至今每一本大冰的书都看了，也算感谢他当初给我的悸动了。但现在沦为一位在书中为自己辩解和洗白的人，大冰算是很卖力了，整本书重复了好多遍所谓“平行世界”的话，也重复了很多遍“你们要看完才有发言权哦”之类的求人看下去的话。无疑很多人还是很羡慕大冰的生活，包括我，洗脑了吧，这种文字看看就好吧。好吗？好的。
+1	电影符号学
+0	国产评分向来不靠谱，这本明显是针对初中生写的超现实（扯淡）推理
+0	天雷滚滚。真不知道为什么家里的妹子会被这种东西感动。
+0	小白文，看着耍
+0	高于1星半。①情节平淡、单薄，人物单薄。女主妈妈得麻风病上岛、女主和姐姐、女主得麻风病上岛、女主治好麻风病下岛、女主姐姐的女儿……越到后面越没耐心越觉得无聊。②除姐姐妹妹部分的其他情节太平淡太单薄，而姐姐妹妹部分更是糟糕、烂大街、狗血、老套：“一不做二不休”的姐妹，姐姐是不做，妹妹是不休。坏心、恶毒、嫉妒心极强、虚荣、爱钱、傍大款的美丽姐姐；真善美哪哪都是好好好没有缺点的妹妹；姐姐抢妹妹男人。姐姐妹妹的情节就只有这些。③女主的2位恋人，前一个是上了几十个处女(招妓就更不用说)的滥交渣男，后一个是比她大20岁的老男人。本来人物就很单薄，留给女主的还那么差。④内容的叙述也就如一开始的“讲故事”的平铺直叙讲述，没有精彩小说该有的令人身临其境的叙述方式。⑤“令整个欧洲潸然泪下……”，真夸张。
+0	不喜欢这个小说，好像就是历史一样的说教。女主没看到多少自主性，好像就是跟着即使走而已，即使让她爱谁就爱谁。
+0	读起来太费劲了，前半段耐着性子读了，后半段草草读过。。。
+0	一流选题，三流内容。论文式写作，文字难有令人灵光乍现的部分。
+1	我竟然读完了，恩，我要去读第二遍了
+1	看得我看什么都像类型片……
+1	以色列真是一片神奇的土地，简直是Nothing is impossible的最好注解呀。反观中国，缺制度、缺文化、缺技能，辽阔疆土却成长不出创新的种子，注定贫瘠、贫乏、毫无生机。。。。杯具
+1	所有人都能读，所有人都该读，我们上课学的历史是小说。
+1	一个荒诞离奇匪夷所思的故事。年少时候的张扬与轻狂，往往会变成生命中的错与伤：我们平凡却可贵的人生，错了不会再重来。
+1	电视剧很好看，没想到小说也那么精彩，堪称经典。
+1	令人映像深刻的是那些挂着灿烂笑容的中国儿童兵~
+1	小时候看电影 觉得香港的一切都是好的 可惜我是个悲观的小孩 觉得我一辈子都没有机会去香港 长大了 却跑到了地球的另一半 没有时间去香港 总有一天我会去香港 看看电影里的街头小巷
+0	除了装帧设计好看，无一好看。作者文笔小学生水平，时常是流水账状态。
+0	“很黄很暴力，恶心倒胃口。” http://book.douban.com/review/6486508/
+1	浪漫主义啊，只是，看完后觉得有好多细节并没有解释清楚。哈迪斯那时对安非说的话，让我以为莫凉在曾经的那个神话中也会有一席之地，可是，总觉得有点虎头蛇尾的嫌疑~
+0	因罗振宇不负责的坑爹点评,再减一星!
+0	情节不清晰，故事整个编的天花乱坠，钱像扔沙子是的写；那富丽堂皇想什么就有什么。感觉里面的人除了女主都是一个外星人一样，可以看穿人的内心；尼玛，哪有这么简单。这种完美就反衬人物不鲜明，虚得太多。文章也就这样。
+1	卡尔维诺式的卡尔维诺只能是卡尔维诺
+1	戴在国内应该算是蛮不错的学者。国内的电影理论圈的众多学者，仅仅还停留在理解国外理论的水平。对于第二符号学来说，国内连理解的学者都没几个。基本只是套用精神分析的术语，解读思路还是自己固有的那一套。戴老师也不能免俗。
+0	男主傻逼。
+1	好书，应该去读英文原文，把英语给好好学学。十二个案例的第一个就是2015年的6月的中国股市，
+1	下午三点，不早不晚
+1	看起来有点吃力，数学底子不够好。
+0	看来还是不能盲目轻信友邻安利
+0	只看了几个故事，总觉得感觉怪怪，这明明是打着丽江旗号的爱情小说集子么，最重要的是，这些小说还写得如此之烂
+1	可以说很精彩了。
+1	已购。粉丝向，内容还是有点单薄。异形第一部是小时候看的录像带，几乎要被吓死了，尤其看到抱脸虫，现在还有阴影。。。吓得我后面几部至今没敢看。。。
+0	啊看不下去
+0	以中东为中心，描述世界历史。多少有点牵强，中国是个打酱油的角色。翻译不喜欢，勉强看完了。
+0	日记体 没深度
+0	中二病可以醒醒了哦。
+1	真是很有意思的人呢
+0	无趣、无聊！竟然起了一个这么费正清式的名字，坑爹不浅呀
+1	听奥胖口无遮拦地谈论各种八卦轶事真是有趣，但看到最后雅格洛后记里孤独的奥胖却让我险些落下泪来。
+1	本书除了延续了丹·布朗一贯知识丰富和情结紧凑的特点之外，还探讨了人和神，宗教和科学等大命题，绝对经典，看得我拍案惊呼。
+1	在陕西汉中留坝书房读完，喝着卡布提诺，烤着火，美美的懒懒的，内容就没那么轻松，以色列建国不容易，巴勒斯坦阿拉伯人更不容易，历史造成的悲剧没人能解决，最后恐怕还得历史来解决。
+1	用诗意的文字来书写血腥内战中的救赎与人性。 好的译笔让人融入其中，荡气回肠。译后记也相当凝练。
+1	购买正版电子书生涯开始，kindle app在iPad上的阅读体验也甩其他同类app几条街！
+0	很适合翻拍影视剧，该有的套路都有，就是看不到真情
+1	看一个喜欢的导演讲自己怎么拍戏总是觉得很有趣，尤其是现在几乎不看DVD，也就失去了看导演讲解音轨的机会。
+0	突然有一天有人依靠着经济发财了,于是一大堆人跟进发经济财,再后来有个折腾文字的人也去凑经济的热闹
+0	弃了，读点儿有用的吧，加油
+0	【这个故事说的是一个无意中穿越的女人犯了一种叫玛丽苏的病经过不懈努力终于把自己活活虐死的故事】妈的我就不总结了……豆友的这句实在是不能更经典了……严格说去掉女猪，只看桐华女士写的二月河九龙夺嫡同人，倒是篇有意思的东西，可惜清穿这题材决定了她玩儿命的把女主插进去并让她影响每件大事的进程，崩坏也就可以想见……
+1	短经典系列也读了不少了，萨冈本人的故事就很精彩了，而这本集子里所收录的内容也非常有趣，好的短篇小说读完总有意犹未尽之感，那些生活中小小的细节，小小的忧愁，婚姻，两性，出轨，绝症，对于生活的绝望。。。对于任何一个阶级的人都会产生如石头落入池塘中的涟漪吧。很多事别人不觉得有什么大不了，可是敏感的人却会想很多，我觉得萨冈真是把握了很多人们这种心理，没什么波澜起伏的故事，硬生生的却叫人感同身受了。也可能这的确是更适合心思敏感的人看的书吧。
+0	这对儿没什么大意思。
+0	嗯 我又重新学习了中央银行的各项职能 书名直接用副标题更好
+1	波澜壮阔，细致入微。
+0	没看过.看题目就是个废
+0	n63不如看原典
+1	唏嘘不已
+1	刚开始看的昏昏欲睡，这牛逼也吹的太响当当了，后来小说渐入佳境，倪匡没有忽悠可怜的读者，这绝逼是所谓的终生小说，武侠小说的终极也不过如此了。。。看了九把刀的新书《价值连城的幸运》后面九把刀的访谈，好像他和张大春有点过节，不知道哪位能给我科普一下。。。。。
+0	总是在重复那几句不痛不痒的话，无味。拓宽知识量看着玩玩。
+0	不知所言╮(￣▽￣")╭
+1	还行吧，不错
+1	本书汇聚了1978年以来中国改革开放带来的巨大变化，经济改革是主线，展现了各类经济体在政策浪潮下的前行，生动刻画了村镇企业、国营企业、个体户、挂靠集体企业的红帽子企业，合资企业的发展和其代表人物，既有政治上的宦海浮沉，又有普通小老百姓精神风貌的变化，实在是一部不可多得的小说！
+0	无法摆脱的虚假和做作感 越往后越甚
+1	不错，中间人物关系镜头运用的分析，特别清晰精彩。。。。。。。。。。。。。。。。。。。。。。。。。。。。��。。。。。。。。。。。。。。。。。。。。。。。。。
+0	天子谋同一作者，但这本没看进去。人设就相当诡异，出场人物暗设看不懂，关系很乱。继续看也许会看懂。
+1	零散不精炼，但有借鉴意义。
+0	努力了两次，最终还是跟这书漫长的告别了

train/documents/llama.md

@@ -0,0 +1,52 @@
+
+## Training
+
+1. Clone the TencentPretrain project and install dependencies: PyTorch, DeepSpeed, SentencePiece
+
+```
+git clone https://github.com/Tencent/TencentPretrain.git
+```
+
+2. Convert LLaMA-7B weights to TencentPretrain format
+
+```
+cd TencentPretrain
+
+python3 scripts/convert_llama_to_tencentpretrain.py --input_model_path $LLaMA_7B_FOLDER/consolidated.00.pth --output_model_path models/llama-7b.bin --layers_num 32
+```
+
+3. Modify configuration file
+
+Check out the `tencentpretrain/utils/constants.py` file, and modify L4: `special_tokens_map.json` to `llama_special_tokens_map.json`
+
+4. Data preprocess. We use the example corpus in the project for pre-training, one can also use custom data training in the same format (one sample per line).
+
+```
+python3 preprocess.py --corpus_path corpora/book_review.txt --spm_model_path $LLaMA_7B_FOLDER/tokenizer.model \
+                      --dataset_path dataset.pt --processes_num 8 --data_processor lm
+```
+
+5. Start training.
+
+```
+deepspeed pretrain.py --deepspeed --deepspeed_config models/deepspeed_config.json \
+                      --pretrained_model_path models/llama-7b.bin \
+                      --dataset_path dataset.pt --spm_model_path $LLaMA_7B_FOLDER/tokenizer.model \
+                      --config_path models/llama/7b_config.json \
+                      --output_model_path models/output_model.bin \
+                      --world_size 8 --learning_rate 1e-4  \
+                      --data_processor lm --total_steps 10000 --save_checkpoint_steps 2000 --batch_size 24
+```
+
+## Inference
+
+Similar to facebookresearch/llama, TencentPretrain also provides language model inference code. 
+For example, using a single GPU for LLaMA-7B inference, the prompt is in the file `beginning.txt`:
+
+```
+python3 scripts/generate_lm.py --load_model_path models/llama-7b.bin --spm_model_path $LLaMA_7B_FOLDER/tokenizer.model \
+                               --test_path beginning.txt --prediction_path generated_sentence.txt \
+                               --config_path models/llama/7b_config.json 
+```
+
+For now, TencentPretrain only support LLaMA-7B training. We are working on our framework to support LLaMA model training/fine-tuning at all scales and sharing more experimental results.

train/finetune/run_c3.py

@@ -0,0 +1,215 @@
+"""
+This script provides an example to wrap TencentPretrain for C3 (a multiple choice dataset).
+"""
+import sys
+import os
+import argparse
+import json
+import random
+import torch
+import torch.nn as nn
+
+tencentpretrain_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(tencentpretrain_dir)
+
+from tencentpretrain.embeddings import *
+from tencentpretrain.encoders import *
+from tencentpretrain.utils.constants import *
+from tencentpretrain.utils import *
+from tencentpretrain.utils.optimizers import *
+from tencentpretrain.utils.config import load_hyperparam
+from tencentpretrain.utils.seed import set_seed
+from tencentpretrain.utils.logging import init_logger
+from tencentpretrain.model_saver import save_model
+from tencentpretrain.opts import finetune_opts, tokenizer_opts, adv_opts
+from finetune.run_classifier import build_optimizer, load_or_initialize_parameters, train_model, batch_loader, evaluate
+
+
+class MultipleChoice(nn.Module):
+    def __init__(self, args):
+        super(MultipleChoice, self).__init__()
+        self.embedding = Embedding(args)
+        for embedding_name in args.embedding:
+            tmp_emb = str2embedding[embedding_name](args, len(args.tokenizer.vocab))
+            self.embedding.update(tmp_emb, embedding_name)
+        self.encoder = str2encoder[args.encoder](args)
+        self.dropout = nn.Dropout(args.dropout)
+        self.output_layer = nn.Linear(args.hidden_size, 1)
+
+    def forward(self, src, tgt, seg, soft_tgt=None):
+        """
+        Args:
+            src: [batch_size x choices_num x seq_length]
+            tgt: [batch_size]
+            seg: [batch_size x choices_num x seq_length]
+        """
+
+        choices_num = src.shape[1]
+
+        src = src.view(-1, src.size(-1))
+        seg = seg.view(-1, seg.size(-1))
+
+        # Embedding.
+        emb = self.embedding(src, seg)
+        # Encoder.
+        output = self.encoder(emb, seg)
+        output = self.dropout(output)
+        logits = self.output_layer(output[:, 0, :])
+        reshaped_logits = logits.view(-1, choices_num)
+
+        if tgt is not None:
+            loss = nn.NLLLoss()(nn.LogSoftmax(dim=-1)(reshaped_logits), tgt.view(-1))
+            return loss, reshaped_logits
+        else:
+            return None, reshaped_logits
+
+
+def read_dataset(args, path):
+
+    with open(path, mode="r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    examples = []
+    for i in range(len(data)):
+        for j in range(len(data[i][1])):
+            example = ["\n".join(data[i][0]).lower(), data[i][1][j]["question"].lower()]
+            for k in range(len(data[i][1][j]["choice"])):
+                example += [data[i][1][j]["choice"][k].lower()]
+            for k in range(len(data[i][1][j]["choice"]), args.max_choices_num):
+                example += ["No Answer"]
+
+            example += [data[i][1][j].get("answer", "").lower()]
+
+            examples += [example]
+
+    dataset = []
+    for i, example in enumerate(examples):
+        tgt = 0
+        for k in range(args.max_choices_num):
+            if example[2 + k] == example[6]:
+                tgt = k
+        dataset.append(([], tgt, []))
+
+        for k in range(args.max_choices_num):
+
+            src_a = args.tokenizer.convert_tokens_to_ids([CLS_TOKEN] + args.tokenizer.tokenize(example[k + 2]) + [SEP_TOKEN])
+            src_b = args.tokenizer.convert_tokens_to_ids(args.tokenizer.tokenize(example[1]) + [SEP_TOKEN])
+            src_c = args.tokenizer.convert_tokens_to_ids(args.tokenizer.tokenize(example[0]) + [SEP_TOKEN])
+
+            src = src_a + src_b + src_c
+            seg = [1] * (len(src_a) + len(src_b)) + [2] * len(src_c)
+
+            if len(src) > args.seq_length:
+                src = src[: args.seq_length]
+                seg = seg[: args.seq_length]
+            PAD_ID = args.tokenizer.convert_tokens_to_ids([PAD_TOKEN])[0]
+            while len(src) < args.seq_length:
+                src.append(PAD_ID)
+                seg.append(0)
+
+            dataset[-1][0].append(src)
+            dataset[-1][2].append(seg)
+
+    return dataset
+
+
+def main():
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    finetune_opts(parser)
+
+    parser.add_argument("--max_choices_num", default=4, type=int,
+                        help="The maximum number of cadicate answer, shorter than this will be padded.")
+
+    tokenizer_opts(parser)
+
+    adv_opts(parser)
+
+    args = parser.parse_args()
+    args.labels_num = args.max_choices_num
+
+    # Load the hyperparameters from the config file.
+    args = load_hyperparam(args)
+
+    set_seed(args.seed)
+
+    # Build tokenizer.
+    args.tokenizer = str2tokenizer[args.tokenizer](args)
+
+    # Build multiple choice model.
+    model = MultipleChoice(args)
+
+    # Load or initialize parameters.
+    load_or_initialize_parameters(args, model)
+
+    # Get logger.
+    args.logger = init_logger(args)
+
+    args.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(args.device)
+
+    # Training phase.
+    trainset = read_dataset(args, args.train_path)
+    instances_num = len(trainset)
+    batch_size = args.batch_size
+
+    args.train_steps = int(instances_num * args.epochs_num / batch_size) + 1
+
+    args.logger.info("Batch size: {}".format(batch_size))
+    args.logger.info("The number of training instances: {}".format(instances_num))
+
+    optimizer, scheduler = build_optimizer(args, model)
+
+    if args.fp16:
+        try:
+            from apex import amp
+        except ImportError:
+            raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
+        model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level)
+        args.amp = amp
+
+    if torch.cuda.device_count() > 1:
+        args.logger.info("{} GPUs are available. Let's use them.".format(torch.cuda.device_count()))
+        model = torch.nn.DataParallel(model)
+    args.model = model
+
+    if args.use_adv:
+        args.adv_method = str2adv[args.adv_type](model)
+
+    total_loss, result, best_result = 0.0, 0.0, 0.0
+
+    args.logger.info("Start training.")
+
+    for epoch in range(1, args.epochs_num + 1):
+        random.shuffle(trainset)
+        src = torch.LongTensor([example[0] for example in trainset])
+        tgt = torch.LongTensor([example[1] for example in trainset])
+        seg = torch.LongTensor([example[2] for example in trainset])
+
+        model.train()
+        for i, (src_batch, tgt_batch, seg_batch, _) in enumerate(batch_loader(batch_size, src, tgt, seg)):
+
+            loss = train_model(args, model, optimizer, scheduler, src_batch, tgt_batch, seg_batch)
+            total_loss += loss.item()
+
+            if (i + 1) % args.report_steps == 0:
+                args.logger.info("Epoch id: {}, Training steps: {}, Avg loss: {:.3f}".format(epoch, i + 1, total_loss / args.report_steps))
+                total_loss = 0.0
+
+        result = evaluate(args, read_dataset(args, args.dev_path))
+        if result[0] > best_result:
+            best_result = result[0]
+            save_model(model, args.output_model_path)
+
+    # Evaluation phase.
+    if args.test_path is not None:
+        args.logger.info("Test set evaluation.")
+        if torch.cuda.device_count() > 1:
+            args.model.module.load_state_dict(torch.load(args.output_model_path))
+        else:
+            args.model.load_state_dict(torch.load(args.output_model_path))
+        evaluate(args, read_dataset(args, args.test_path))
+
+
+if __name__ == "__main__":
+    main()

train/finetune/run_chid.py

@@ -0,0 +1,225 @@
+"""
+This script provides an example to wrap TencentPretrain for ChID (a multiple choice dataset).
+"""
+import sys
+import os
+import argparse
+import json
+import random
+import torch
+
+tencentpretrain_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(tencentpretrain_dir)
+
+from tencentpretrain.utils.constants import *
+from tencentpretrain.utils.tokenizers import *
+from tencentpretrain.utils.optimizers import *
+from tencentpretrain.utils import *
+from tencentpretrain.utils.config import load_hyperparam
+from tencentpretrain.utils.seed import set_seed
+from tencentpretrain.utils.logging import init_logger
+from tencentpretrain.model_saver import save_model
+from tencentpretrain.opts import finetune_opts, adv_opts
+from finetune.run_c3 import MultipleChoice
+from finetune.run_classifier import build_optimizer, load_or_initialize_parameters, train_model, batch_loader, evaluate
+
+
+def tokenize_chid(text):
+    output = []
+    first_idiom = True
+    while True:
+        if first_idiom:
+            idiom_index = text.find("#idiom")
+            output.extend(text[:idiom_index])
+            output.append(text[idiom_index : idiom_index + 13])
+            pre_idiom_index = idiom_index
+            first_idiom = False
+        else:
+            if text[idiom_index + 1 :].find("#idiom") == -1:
+                output.extend(text[pre_idiom_index + 13 :])
+                break
+            else:
+                idiom_index = idiom_index + 1 + text[idiom_index + 1 :].find("#idiom")
+                output.extend(text[pre_idiom_index + 13 : idiom_index])
+                output.append(text[idiom_index : idiom_index + 13])
+                pre_idiom_index = idiom_index
+
+    return output
+
+
+def add_tokens_around(tokens, idiom_index, tokens_num):
+    left_tokens_num = tokens_num // 2
+    right_tokens_num = tokens_num - left_tokens_num
+
+    if idiom_index >= left_tokens_num and (len(tokens) - 1 - idiom_index) >= right_tokens_num:
+        left_tokens = tokens[idiom_index - left_tokens_num : idiom_index]
+        right_tokens = tokens[idiom_index + 1 : idiom_index + 1 + right_tokens_num]
+    elif idiom_index < left_tokens_num:
+        left_tokens = tokens[:idiom_index]
+        right_tokens = tokens[idiom_index + 1 : idiom_index + 1 + tokens_num - len(left_tokens)]
+    elif (len(tokens) - 1 - idiom_index) < right_tokens_num:
+        right_tokens = tokens[idiom_index + 1 :]
+        left_tokens = tokens[idiom_index - (tokens_num - len(right_tokens)) : idiom_index]
+
+    return left_tokens, right_tokens
+
+
+def read_dataset(args, data_path, answer_path):
+    if answer_path is not None:
+        answers = json.load(open(answer_path))
+    dataset = []
+    max_tokens_for_doc = args.seq_length - 3
+    group_index = 0
+
+    for line in open(data_path, mode="r", encoding="utf-8"):
+        example = json.loads(line)
+        options = example["candidates"]
+        for context in example["content"]:
+            chid_tokens = tokenize_chid(context)
+            tags = [token for token in chid_tokens if "#idiom" in token]
+            for tag in tags:
+                if answer_path is not None:
+                    tgt = answers[tag]
+                else:
+                    tgt = -1
+                tokens = []
+                for i, token in enumerate(chid_tokens):
+                    if "#idiom" in token:
+                        sub_tokens = [str(token)]
+                    else:
+                        sub_tokens = args.tokenizer.tokenize(token)
+                    for sub_token in sub_tokens:
+                        tokens.append(sub_token)
+                idiom_index = tokens.index(tag)
+                left_tokens, right_tokens = add_tokens_around(tokens, idiom_index, max_tokens_for_doc - 1)
+
+                for i in range(len(left_tokens)):
+                    if "#idiom" in left_tokens[i] and left_tokens[i] != tag:
+                        left_tokens[i] = MASK_TOKEN
+                for i in range(len(right_tokens)):
+                    if "#idiom" in right_tokens[i] and right_tokens[i] != tag:
+                        right_tokens[i] = MASK_TOKEN
+
+                dataset.append(([], tgt, [], tag, group_index))
+
+                for option in options:
+                    option_tokens = args.tokenizer.tokenize(option)
+                    tokens = [CLS_TOKEN] + option_tokens + [SEP_TOKEN] + left_tokens + [SEP_TOKEN] + right_tokens + [SEP_TOKEN]
+
+                    src = args.tokenizer.convert_tokens_to_ids(tokens)[: args.seq_length]
+                    seg = [0] * len(src)
+
+                    while len(src) < args.seq_length:
+                        src.append(0)
+                        seg.append(0)
+
+                    dataset[-1][0].append(src)
+                    dataset[-1][2].append(seg)
+
+                while len(dataset[-1][0]) < args.max_choices_num:
+                    dataset[-1][0].append([0] * args.seq_length)
+                    dataset[-1][2].append([0] * args.seq_length)
+        group_index += 1
+
+    return dataset
+
+
+def main():
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    finetune_opts(parser)
+
+    parser.add_argument("--vocab_path", default=None, type=str,
+                        help="Path of the vocabulary file.")
+    parser.add_argument("--spm_model_path", default=None, type=str,
+                        help="Path of the sentence piece model.")
+    parser.add_argument("--train_answer_path", type=str, required=True,
+                        help="Path of the answers for trainset.")
+    parser.add_argument("--dev_answer_path", type=str, required=True,
+                        help="Path of the answers for devset.")
+
+    parser.add_argument("--max_choices_num", default=10, type=int,
+                        help="The maximum number of cadicate answer, shorter than this will be padded.")
+
+    adv_opts(parser)
+
+    args = parser.parse_args()
+
+    args.labels_num = args.max_choices_num
+
+    # Load the hyperparameters from the config file.
+    args = load_hyperparam(args)
+
+    set_seed(args.seed)
+
+    # Build tokenizer.
+    args.tokenizer = CharTokenizer(args)
+
+    # Build multiple choice model.
+    model = MultipleChoice(args)
+
+    # Load or initialize parameters.
+    load_or_initialize_parameters(args, model)
+
+    # Get logger.
+    args.logger = init_logger(args)
+
+    args.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(args.device)
+
+    # Training phase.
+    trainset = read_dataset(args, args.train_path, args.train_answer_path)
+    instances_num = len(trainset)
+    batch_size = args.batch_size
+
+    args.train_steps = int(instances_num * args.epochs_num / batch_size) + 1
+
+    args.logger.info("Batch size: {}".format(batch_size))
+    args.logger.info("The number of training instances: {}".format(instances_num))
+
+    optimizer, scheduler = build_optimizer(args, model)
+
+    if args.fp16:
+        try:
+            from apex import amp
+        except ImportError:
+            raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
+        model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level)
+        args.amp = amp
+
+    if torch.cuda.device_count() > 1:
+        args.logger.info("{} GPUs are available. Let's use them.".format(torch.cuda.device_count()))
+        model = torch.nn.DataParallel(model)
+    args.model = model
+
+    if args.use_adv:
+        args.adv_method = str2adv[args.adv_type](model)
+
+    total_loss, result, best_result = 0.0, 0.0, 0.0
+
+    args.logger.info("Start training.")
+
+    for epoch in range(1, args.epochs_num + 1):
+        random.shuffle(trainset)
+        src = torch.LongTensor([example[0] for example in trainset])
+        tgt = torch.LongTensor([example[1] for example in trainset])
+        seg = torch.LongTensor([example[2] for example in trainset])
+
+        model.train()
+        for i, (src_batch, tgt_batch, seg_batch, _) in enumerate(batch_loader(batch_size, src, tgt, seg)):
+
+            loss = train_model(args, model, optimizer, scheduler, src_batch, tgt_batch, seg_batch)
+            total_loss += loss.item()
+
+            if (i + 1) % args.report_steps == 0:
+                args.logger.info("Epoch id: {}, Training steps: {}, Avg loss: {:.3f}".format(epoch, i + 1, total_loss / args.report_steps))
+                total_loss = 0.0
+
+        result = evaluate(args, read_dataset(args, args.dev_path, args.dev_answer_path))
+        if result[0] > best_result:
+            best_result = result[0]
+            save_model(model, args.output_model_path)
+
+
+if __name__ == "__main__":
+    main()

train/finetune/run_classifier.py

@@ -0,0 +1,366 @@
+"""
+This script provides an example to wrap TencentPretrain for classification.
+"""
+import sys
+import os
+import random
+import argparse
+import torch
+import torch.nn as nn
+
+tencentpretrain_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(tencentpretrain_dir)
+
+from tencentpretrain.embeddings import *
+from tencentpretrain.encoders import *
+from tencentpretrain.utils.vocab import Vocab
+from tencentpretrain.utils.constants import *
+from tencentpretrain.utils import *
+from tencentpretrain.utils.optimizers import *
+from tencentpretrain.utils.config import load_hyperparam
+from tencentpretrain.utils.seed import set_seed
+from tencentpretrain.utils.logging import init_logger
+from tencentpretrain.utils.misc import pooling
+from tencentpretrain.model_saver import save_model
+from tencentpretrain.opts import finetune_opts, tokenizer_opts, adv_opts
+
+
+class Classifier(nn.Module):
+    def __init__(self, args):
+        super(Classifier, self).__init__()
+        self.embedding = Embedding(args)
+        for embedding_name in args.embedding:
+            tmp_emb = str2embedding[embedding_name](args, len(args.tokenizer.vocab))
+            self.embedding.update(tmp_emb, embedding_name)
+        self.encoder = str2encoder[args.encoder](args)
+        self.labels_num = args.labels_num
+        self.pooling_type = args.pooling
+        self.soft_targets = args.soft_targets
+        self.soft_alpha = args.soft_alpha
+        self.output_layer_1 = nn.Linear(args.hidden_size, args.hidden_size)
+        self.output_layer_2 = nn.Linear(args.hidden_size, self.labels_num)
+
+    def forward(self, src, tgt, seg, soft_tgt=None):
+        """
+        Args:
+            src: [batch_size x seq_length]
+            tgt: [batch_size]
+            seg: [batch_size x seq_length]
+        """
+        # Embedding.
+        emb = self.embedding(src, seg)
+        # Encoder.
+        output = self.encoder(emb, seg)
+        # Target.
+        output = pooling(output, seg, self.pooling_type)
+        output = torch.tanh(self.output_layer_1(output))
+        logits = self.output_layer_2(output)
+        if tgt is not None:
+            if self.soft_targets and soft_tgt is not None:
+                loss = self.soft_alpha * nn.MSELoss()(logits, soft_tgt) + \
+                       (1 - self.soft_alpha) * nn.NLLLoss()(nn.LogSoftmax(dim=-1)(logits), tgt.view(-1))
+            else:
+                loss = nn.NLLLoss()(nn.LogSoftmax(dim=-1)(logits), tgt.view(-1))
+            return loss, logits
+        else:
+            return None, logits
+
+
+def count_labels_num(path):
+    labels_set, columns = set(), {}
+    with open(path, mode="r", encoding="utf-8") as f:
+        for line_id, line in enumerate(f):
+            if line_id == 0:
+                for i, column_name in enumerate(line.rstrip("\r\n").split("\t")):
+                    columns[column_name] = i
+                continue
+            line = line.rstrip("\r\n").split("\t")
+            label = int(line[columns["label"]])
+            labels_set.add(label)
+    return len(labels_set)
+
+
+def load_or_initialize_parameters(args, model):
+    if args.pretrained_model_path is not None:
+        # Initialize with pretrained model.
+        model.load_state_dict(torch.load(args.pretrained_model_path, map_location="cpu"), strict=False)
+    else:
+        # Initialize with normal distribution.
+        for n, p in list(model.named_parameters()):
+            if "gamma" not in n and "beta" not in n:
+                p.data.normal_(0, 0.02)
+
+
+def build_optimizer(args, model):
+    param_optimizer = list(model.named_parameters())
+    no_decay = ["bias", "gamma", "beta"]
+    optimizer_grouped_parameters = [
+        {"params": [p for n, p in param_optimizer if not any(nd in n for nd in no_decay)], "weight_decay": 0.01},
+        {"params": [p for n, p in param_optimizer if any(nd in n for nd in no_decay)], "weight_decay": 0.0},
+    ]
+    if args.optimizer in ["adamw"]:
+        optimizer = str2optimizer[args.optimizer](optimizer_grouped_parameters, lr=args.learning_rate, correct_bias=False)
+    else:
+        optimizer = str2optimizer[args.optimizer](optimizer_grouped_parameters, lr=args.learning_rate,
+                                                  scale_parameter=False, relative_step=False)
+    if args.scheduler in ["constant"]:
+        scheduler = str2scheduler[args.scheduler](optimizer)
+    elif args.scheduler in ["constant_with_warmup"]:
+        scheduler = str2scheduler[args.scheduler](optimizer, args.train_steps*args.warmup)
+    else:
+        scheduler = str2scheduler[args.scheduler](optimizer, args.train_steps*args.warmup, args.train_steps)
+    return optimizer, scheduler
+
+
+def batch_loader(batch_size, src, tgt, seg, soft_tgt=None):
+    instances_num = src.size()[0]
+    for i in range(instances_num // batch_size):
+        src_batch = src[i * batch_size : (i + 1) * batch_size, :]
+        tgt_batch = tgt[i * batch_size : (i + 1) * batch_size]
+        seg_batch = seg[i * batch_size : (i + 1) * batch_size, :]
+        if soft_tgt is not None:
+            soft_tgt_batch = soft_tgt[i * batch_size : (i + 1) * batch_size, :]
+            yield src_batch, tgt_batch, seg_batch, soft_tgt_batch
+        else:
+            yield src_batch, tgt_batch, seg_batch, None
+    if instances_num > instances_num // batch_size * batch_size:
+        src_batch = src[instances_num // batch_size * batch_size :, :]
+        tgt_batch = tgt[instances_num // batch_size * batch_size :]
+        seg_batch = seg[instances_num // batch_size * batch_size :, :]
+        if soft_tgt is not None:
+            soft_tgt_batch = soft_tgt[instances_num // batch_size * batch_size :, :]
+            yield src_batch, tgt_batch, seg_batch, soft_tgt_batch
+        else:
+            yield src_batch, tgt_batch, seg_batch, None
+
+
+def read_dataset(args, path):
+    dataset, columns = [], {}
+    with open(path, mode="r", encoding="utf-8") as f:
+        for line_id, line in enumerate(f):
+            if line_id == 0:
+                for i, column_name in enumerate(line.rstrip("\r\n").split("\t")):
+                    columns[column_name] = i
+                continue
+            line = line.rstrip("\r\n").split("\t")
+            tgt = int(line[columns["label"]])
+            if args.soft_targets and "logits" in columns.keys():
+                soft_tgt = [float(value) for value in line[columns["logits"]].split(" ")]
+            if "text_b" not in columns:  # Sentence classification.
+                text_a = line[columns["text_a"]]
+                src = args.tokenizer.convert_tokens_to_ids([CLS_TOKEN] + args.tokenizer.tokenize(text_a) + [SEP_TOKEN])
+                seg = [1] * len(src)
+            else:  # Sentence-pair classification.
+                text_a, text_b = line[columns["text_a"]], line[columns["text_b"]]
+                src_a = args.tokenizer.convert_tokens_to_ids([CLS_TOKEN] + args.tokenizer.tokenize(text_a) + [SEP_TOKEN])
+                src_b = args.tokenizer.convert_tokens_to_ids(args.tokenizer.tokenize(text_b) + [SEP_TOKEN])
+                src = src_a + src_b
+                seg = [1] * len(src_a) + [2] * len(src_b)
+
+            if len(src) > args.seq_length:
+                src = src[: args.seq_length]
+                seg = seg[: args.seq_length]
+            PAD_ID = args.tokenizer.convert_tokens_to_ids([PAD_TOKEN])[0]
+            while len(src) < args.seq_length:
+                src.append(PAD_ID)
+                seg.append(0)
+            if args.soft_targets and "logits" in columns.keys():
+                dataset.append((src, tgt, seg, soft_tgt))
+            else:
+                dataset.append((src, tgt, seg))
+
+    return dataset
+
+
+def train_model(args, model, optimizer, scheduler, src_batch, tgt_batch, seg_batch, soft_tgt_batch=None):
+    model.zero_grad()
+
+    src_batch = src_batch.to(args.device)
+    tgt_batch = tgt_batch.to(args.device)
+    seg_batch = seg_batch.to(args.device)
+    if soft_tgt_batch is not None:
+        soft_tgt_batch = soft_tgt_batch.to(args.device)
+
+    loss, _ = model(src_batch, tgt_batch, seg_batch, soft_tgt_batch)
+    if torch.cuda.device_count() > 1:
+        loss = torch.mean(loss)
+
+    if args.fp16:
+        with args.amp.scale_loss(loss, optimizer) as scaled_loss:
+            scaled_loss.backward()
+    else:
+        loss.backward()
+
+    if args.use_adv and args.adv_type == "fgm":
+        args.adv_method.attack(epsilon=args.fgm_epsilon)
+        loss_adv, _ = model(src_batch, tgt_batch, seg_batch, soft_tgt_batch)
+        if torch.cuda.device_count() > 1:
+            loss_adv = torch.mean(loss_adv)
+        loss_adv.backward()
+        args.adv_method.restore()
+
+    if args.use_adv and args.adv_type == "pgd":
+        K = args.pgd_k
+        args.adv_method.backup_grad()
+        for t in range(K):
+            # apply the perturbation to embedding
+            args.adv_method.attack(epsilon=args.pgd_epsilon, alpha=args.pgd_alpha,
+                                   is_first_attack=(t == 0))
+            if t != K - 1:
+                model.zero_grad()
+            else:
+                args.adv_method.restore_grad()
+            loss_adv, _ = model(src_batch, tgt_batch, seg_batch, soft_tgt_batch)
+            if torch.cuda.device_count() > 1:
+                loss_adv = torch.mean(loss_adv)
+            loss_adv.backward()
+        args.adv_method.restore()
+
+    optimizer.step()
+    scheduler.step()
+
+    return loss
+
+
+def evaluate(args, dataset):
+    src = torch.LongTensor([sample[0] for sample in dataset])
+    tgt = torch.LongTensor([sample[1] for sample in dataset])
+    seg = torch.LongTensor([sample[2] for sample in dataset])
+
+    batch_size = args.batch_size
+
+    correct = 0
+    # Confusion matrix.
+    confusion = torch.zeros(args.labels_num, args.labels_num, dtype=torch.long)
+
+    args.model.eval()
+
+    for i, (src_batch, tgt_batch, seg_batch, _) in enumerate(batch_loader(batch_size, src, tgt, seg)):
+        src_batch = src_batch.to(args.device)
+        tgt_batch = tgt_batch.to(args.device)
+        seg_batch = seg_batch.to(args.device)
+        with torch.no_grad():
+            _, logits = args.model(src_batch, tgt_batch, seg_batch)
+        pred = torch.argmax(nn.Softmax(dim=1)(logits), dim=1)
+        gold = tgt_batch
+        for j in range(pred.size()[0]):
+            confusion[pred[j], gold[j]] += 1
+        correct += torch.sum(pred == gold).item()
+
+    args.logger.info("Confusion matrix:")
+    args.logger.info(confusion)
+    args.logger.info("Report precision, recall, and f1:")
+
+    eps = 1e-9
+    for i in range(confusion.size()[0]):
+        p = confusion[i, i].item() / (confusion[i, :].sum().item() + eps)
+        r = confusion[i, i].item() / (confusion[:, i].sum().item() + eps)
+        f1 = 2 * p * r / (p + r + eps)
+        args.logger.info("Label {}: {:.3f}, {:.3f}, {:.3f}".format(i, p, r, f1))
+
+    args.logger.info("Acc. (Correct/Total): {:.4f} ({}/{}) ".format(correct / len(dataset), correct, len(dataset)))
+    return correct / len(dataset), confusion
+
+
+def main():
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    finetune_opts(parser)
+
+    tokenizer_opts(parser)
+
+    parser.add_argument("--soft_targets", action='store_true',
+                        help="Train model with logits.")
+    parser.add_argument("--soft_alpha", type=float, default=0.5,
+                        help="Weight of the soft targets loss.")
+
+    adv_opts(parser)
+
+    args = parser.parse_args()
+
+    # Load the hyperparameters from the config file.
+    args = load_hyperparam(args)
+    # Count the number of labels.
+    args.labels_num = count_labels_num(args.train_path)
+
+    # Build tokenizer.
+    args.tokenizer = str2tokenizer[args.tokenizer](args)
+    set_seed(args.seed)
+
+    # Build classification model.
+    model = Classifier(args)
+
+    # Load or initialize parameters.
+    load_or_initialize_parameters(args, model)
+
+    # Get logger.
+    args.logger = init_logger(args)
+
+    args.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(args.device)
+
+    # Training phase.
+    trainset = read_dataset(args, args.train_path)
+    instances_num = len(trainset)
+    batch_size = args.batch_size
+
+    args.train_steps = int(instances_num * args.epochs_num / batch_size) + 1
+
+    args.logger.info("Batch size: {}".format(batch_size))
+    args.logger.info("The number of training instances: {}".format(instances_num))
+    optimizer, scheduler = build_optimizer(args, model)
+
+    if args.fp16:
+        try:
+            from apex import amp
+        except ImportError:
+            raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
+        model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level)
+        args.amp = amp
+
+    if torch.cuda.device_count() > 1:
+        args.logger.info("{} GPUs are available. Let's use them.".format(torch.cuda.device_count()))
+        model = torch.nn.DataParallel(model)
+    args.model = model
+
+    if args.use_adv:
+        args.adv_method = str2adv[args.adv_type](model)
+
+    total_loss, result, best_result = 0.0, 0.0, 0.0
+
+    args.logger.info("Start training.")
+    for epoch in range(1, args.epochs_num + 1):
+        random.shuffle(trainset)
+        src = torch.LongTensor([example[0] for example in trainset])
+        tgt = torch.LongTensor([example[1] for example in trainset])
+        seg = torch.LongTensor([example[2] for example in trainset])
+        if args.soft_targets:
+            soft_tgt = torch.FloatTensor([example[3] for example in trainset])
+        else:
+            soft_tgt = None
+
+        model.train()
+        for i, (src_batch, tgt_batch, seg_batch, soft_tgt_batch) in enumerate(batch_loader(batch_size, src, tgt, seg, soft_tgt)):
+            loss = train_model(args, model, optimizer, scheduler, src_batch, tgt_batch, seg_batch, soft_tgt_batch)
+            total_loss += loss.item()
+            if (i + 1) % args.report_steps == 0:
+                args.logger.info("Epoch id: {}, Training steps: {}, Avg loss: {:.3f}".format(epoch, i + 1, total_loss / args.report_steps))
+                total_loss = 0.0
+
+        result = evaluate(args, read_dataset(args, args.dev_path))
+        if result[0] > best_result:
+            best_result = result[0]
+            save_model(model, args.output_model_path)
+
+    # Evaluation phase.
+    if args.test_path is not None:
+        args.logger.info("Test set evaluation.")
+        if torch.cuda.device_count() > 1:
+            args.model.module.load_state_dict(torch.load(args.output_model_path))
+        else:
+            args.model.load_state_dict(torch.load(args.output_model_path))
+        evaluate(args, read_dataset(args, args.test_path))
+
+
+if __name__ == "__main__":
+    main()

train/finetune/run_classifier_cv.py

@@ -0,0 +1,173 @@
+"""
+This script provides an example to wrap TencentPretrain for classification with cross validation.
+"""
+import sys
+import os
+import random
+import argparse
+import torch.nn as nn
+import numpy as np
+
+tencentpretrain_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(tencentpretrain_dir)
+
+from tencentpretrain.utils.constants import *
+from tencentpretrain.utils import *
+from tencentpretrain.utils.optimizers import *
+from tencentpretrain.utils.config import load_hyperparam
+from tencentpretrain.utils.seed import set_seed
+from tencentpretrain.model_saver import save_model
+from tencentpretrain.opts import *
+from finetune.run_classifier import *
+
+
+def main():
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    # Path options.
+    parser.add_argument("--pretrained_model_path", default=None, type=str,
+                        help="Path of the pretrained model.")
+    parser.add_argument("--output_model_path", default="models/classifier_model.bin", type=str,
+                        help="Path of the output model.")
+    parser.add_argument("--train_path", type=str, required=True,
+                        help="Path of the trainset.")
+    parser.add_argument("--config_path", default="models/bert/base_config.json", type=str,
+                        help="Path of the config file.")
+    parser.add_argument("--train_features_path", type=str, required=True,
+                        help="Path of the train features for stacking.")
+
+    # Model options.
+    model_opts(parser)
+
+    # Tokenizer options.
+    tokenizer_opts(parser)
+
+    # Optimization options.
+    optimization_opts(parser)
+    parser.add_argument("--soft_targets", action='store_true',
+                        help="Train model with logits.")
+    parser.add_argument("--soft_alpha", type=float, default=0.5,
+                        help="Weight of the soft targets loss.")
+
+    # Training options.
+    training_opts(parser)
+
+    # Cross validation options.
+    parser.add_argument("--folds_num", type=int, default=5,
+                        help="The number of folds for cross validation.")
+
+    adv_opts(parser)
+
+    args = parser.parse_args()
+
+    # Load the hyperparameters from the config file.
+    args = load_hyperparam(args)
+
+    # Get logger.
+    args.logger = init_logger(args)
+
+    set_seed(args.seed)
+
+    # Count the number of labels.
+    args.labels_num = count_labels_num(args.train_path)
+
+    # Build tokenizer.
+    args.tokenizer = str2tokenizer[args.tokenizer](args)
+
+    # Training phase.
+    dataset = read_dataset(args, args.train_path)
+    instances_num = len(dataset)
+    batch_size = args.batch_size
+    instances_num_per_fold = instances_num // args.folds_num + 1
+
+    args.train_steps = int(instances_num * args.epochs_num / batch_size) + 1
+
+    train_features = []
+
+    total_loss, result = 0.0, 0.0
+    acc, marco_f1 = 0.0, 0.0
+
+    for fold_id in range(args.folds_num):
+        # Build classification model.
+        model = Classifier(args)
+
+        args.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        model = model.to(args.device)
+        load_or_initialize_parameters(args, model)
+        optimizer, scheduler = build_optimizer(args, model)
+        if args.fp16:
+            try:
+                from apex import amp
+            except ImportError:
+                raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
+            model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level)
+            args.amp = amp
+        if torch.cuda.device_count() > 1:
+            model = torch.nn.DataParallel(model)
+        args.model = model
+
+        if args.use_adv:
+            args.adv_method = str2adv[args.adv_type](model)
+
+        trainset = dataset[0 : fold_id * instances_num_per_fold] + dataset[(fold_id + 1) * instances_num_per_fold :]
+
+        devset = dataset[fold_id * instances_num_per_fold : (fold_id + 1) * instances_num_per_fold]
+
+        dev_src = torch.LongTensor([example[0] for example in devset])
+        dev_tgt = torch.LongTensor([example[1] for example in devset])
+        dev_seg = torch.LongTensor([example[2] for example in devset])
+        dev_soft_tgt = None
+
+        for epoch in range(1, args.epochs_num + 1):
+            random.shuffle(trainset)
+
+            train_src = torch.LongTensor([example[0] for example in trainset])
+            train_tgt = torch.LongTensor([example[1] for example in trainset])
+            train_seg = torch.LongTensor([example[2] for example in trainset])
+
+            if args.soft_targets:
+                train_soft_tgt = torch.FloatTensor([example[3] for example in trainset])
+            else:
+                train_soft_tgt = None
+
+            model.train()
+            for i, (src_batch, tgt_batch, seg_batch, soft_tgt_batch) in enumerate(batch_loader(batch_size, train_src, train_tgt, train_seg, train_soft_tgt)):
+                loss = train_model(args, model, optimizer, scheduler, src_batch, tgt_batch, seg_batch, soft_tgt_batch)
+                total_loss += loss.item()
+                if (i + 1) % args.report_steps == 0:
+                    args.logger.info("Fold id: {}, Epoch id: {}, Training steps: {}, Avg loss: {:.3f}".format(fold_id, epoch, i + 1, total_loss / args.report_steps))
+                    total_loss = 0.0
+
+        model.eval()
+        for i, (src_batch, tgt_batch, seg_batch, soft_tgt_batch) in enumerate(batch_loader(batch_size, dev_src, dev_tgt, dev_seg, dev_soft_tgt)):
+            src_batch = src_batch.to(args.device)
+            seg_batch = seg_batch.to(args.device)
+            with torch.no_grad():
+                _, logits = model(src_batch, None, seg_batch)
+            prob = nn.Softmax(dim=1)(logits)
+            prob = prob.cpu().numpy().tolist()
+            train_features.extend(prob)
+
+        output_model_name = ".".join(args.output_model_path.split(".")[:-1])
+        output_model_suffix = args.output_model_path.split(".")[-1]
+        save_model(model, output_model_name + "-fold_" + str(fold_id) + "." + output_model_suffix)
+        result = evaluate(args, devset)
+        acc += result[0] / args.folds_num
+        f1 = []
+        confusion = result[1]
+        eps = 1e-9
+        for i in range(confusion.size()[0]):
+            p = confusion[i, i].item() / (confusion[i, :].sum().item() + eps)
+            r = confusion[i, i].item() / (confusion[:, i].sum().item() + eps)
+            f1.append(2 * p * r / (p + r + eps))
+
+        marco_f1 += sum(f1) / len(f1) / args.folds_num
+
+    train_features = np.array(train_features)
+    np.save(args.train_features_path, train_features)
+    args.logger.info("Acc. : {:.4f}".format(acc))
+    args.logger.info("Marco F1 : {:.4f}".format(marco_f1))
+
+
+if __name__ == "__main__":
+    main()

train/finetune/run_classifier_deepspeed.py

@@ -0,0 +1,212 @@
+"""
+This script provides an example to use DeepSpeed for classification.
+"""
+import sys
+import os
+import random
+import argparse
+import torch
+import torch.nn as nn
+import deepspeed
+import torch.distributed as dist
+
+tencentpretrain_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(tencentpretrain_dir)
+
+from tencentpretrain.opts import deepspeed_opts
+from finetune.run_classifier import *
+
+
+def read_dataset(args, path, split):
+    dataset, columns = [], {}
+    if split:
+        for i in range(args.world_size):
+            dataset.append([])
+        index = 0
+    with open(path, mode="r", encoding="utf-8") as f:
+        for line_id, line in enumerate(f):
+            if line_id == 0:
+                for i, column_name in enumerate(line.rstrip("\r\n").split("\t")):
+                    columns[column_name] = i
+                continue
+            line = line.rstrip("\r\n").split("\t")
+            tgt = int(line[columns["label"]])
+            if args.soft_targets and "logits" in columns.keys():
+                soft_tgt = [float(value) for value in line[columns["logits"]].split(" ")]
+            if "text_b" not in columns:  # Sentence classification.
+                text_a = line[columns["text_a"]]
+                src = args.tokenizer.convert_tokens_to_ids([CLS_TOKEN] + args.tokenizer.tokenize(text_a) + [SEP_TOKEN])
+                seg = [1] * len(src)
+            else:  # Sentence-pair classification.
+                text_a, text_b = line[columns["text_a"]], line[columns["text_b"]]
+                src_a = args.tokenizer.convert_tokens_to_ids([CLS_TOKEN] + args.tokenizer.tokenize(text_a) + [SEP_TOKEN])
+                src_b = args.tokenizer.convert_tokens_to_ids(args.tokenizer.tokenize(text_b) + [SEP_TOKEN])
+                src = src_a + src_b
+                seg = [1] * len(src_a) + [2] * len(src_b)
+
+            if len(src) > args.seq_length:
+                src = src[: args.seq_length]
+                seg = seg[: args.seq_length]
+            PAD_ID = args.tokenizer.convert_tokens_to_ids([PAD_TOKEN])[0]
+            while len(src) < args.seq_length:
+                src.append(PAD_ID)
+                seg.append(0)
+            if split:
+                if args.soft_targets and "logits" in columns.keys():
+                    dataset[index].append((src, tgt, seg, soft_tgt))
+                else:
+                    dataset[index].append((src, tgt, seg))
+                index += 1
+                if index == args.world_size:
+                    index = 0
+            else:
+                if args.soft_targets and "logits" in columns.keys():
+                    dataset.append((src, tgt, seg, soft_tgt))
+                else:
+                    dataset.append((src, tgt, seg))
+    if split:
+        max_data_num_rank_index = 0
+        max_data_num = len(dataset[0])
+        for i in range(args.world_size):
+            if len(dataset[i]) > max_data_num:
+                max_data_num_rank_index = i
+                max_data_num = len(dataset[i])
+        for i in range(args.world_size):
+            if len(dataset[i]) < max_data_num:
+                dataset[i].append(dataset[max_data_num_rank_index][-1])
+
+    return dataset
+
+
+def train_model(args, model, optimizer, scheduler, src_batch, tgt_batch, seg_batch, soft_tgt_batch=None):
+    model.zero_grad()
+
+    src_batch = src_batch.to(args.device)
+    tgt_batch = tgt_batch.to(args.device)
+    seg_batch = seg_batch.to(args.device)
+    if soft_tgt_batch is not None:
+        soft_tgt_batch = soft_tgt_batch.to(args.device)
+
+    loss, _ = model(src_batch, tgt_batch, seg_batch, soft_tgt_batch)
+    if torch.cuda.device_count() > 1:
+        loss = torch.mean(loss)
+
+    model.backward(loss)
+
+    model.step()
+
+    return loss
+
+
+def main():
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    finetune_opts(parser)
+
+    parser.add_argument("--world_size", type=int, default=1,
+                        help="Total number of processes (GPUs) for training.")
+
+    tokenizer_opts(parser)
+
+    parser.add_argument("--soft_targets", action='store_true',
+                        help="Train model with logits.")
+    parser.add_argument("--soft_alpha", type=float, default=0.5,
+                        help="Weight of the soft targets loss.")
+
+    deepspeed_opts(parser)
+
+    args = parser.parse_args()
+
+    # Load the hyperparameters from the config file.
+    args = load_hyperparam(args)
+
+    set_seed(args.seed)
+
+    # Count the number of labels.
+    args.labels_num = count_labels_num(args.train_path)
+
+    # Build tokenizer.
+    args.tokenizer = str2tokenizer[args.tokenizer](args)
+
+    # Build classification model.
+    model = Classifier(args)
+
+    # Load or initialize parameters.
+    load_or_initialize_parameters(args, model)
+
+    # Get logger.
+    args.logger = init_logger(args)
+
+    param_optimizer = list(model.named_parameters())
+    no_decay = ["bias", "gamma", "beta"]
+    optimizer_grouped_parameters = [
+        {"params": [p for n, p in param_optimizer if not any(nd in n for nd in no_decay)], "weight_decay": 0.01},
+        {"params": [p for n, p in param_optimizer if any(nd in n for nd in no_decay)], "weight_decay": 0.0},
+    ]
+
+    deepspeed.init_distributed()
+    rank = dist.get_rank()
+    args.rank = rank
+
+    trainset = read_dataset(args, args.train_path, split=True)[args.rank]
+    random.shuffle(trainset)
+    instances_num = len(trainset)
+    batch_size = args.batch_size
+    args.train_steps = int(instances_num * args.epochs_num / batch_size) + 1
+
+    custom_optimizer, custom_scheduler = build_optimizer(args, model)
+
+    model, optimizer, _, scheduler = deepspeed.initialize(
+        model=model,
+        model_parameters=optimizer_grouped_parameters,
+        args=args,
+        optimizer=custom_optimizer,
+        lr_scheduler=custom_scheduler,
+        mpu=None,
+        dist_init_required=False)
+
+    src = torch.LongTensor([example[0] for example in trainset])
+    tgt = torch.LongTensor([example[1] for example in trainset])
+    seg = torch.LongTensor([example[2] for example in trainset])
+    if args.soft_targets:
+        soft_tgt = torch.FloatTensor([example[3] for example in trainset])
+    else:
+        soft_tgt = None
+
+    args.model = model
+    args.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    total_loss, result, best_result, best_epoch = 0.0, 0.0, 0.0, 0
+
+    result_tensor = torch.tensor(result).to(args.device)
+    if args.rank == 0:
+        args.logger.info("Batch size: {}".format(batch_size))
+        args.logger.info("The number of training instances: {}".format(instances_num))
+        args.logger.info("Start training.")
+
+    for epoch in range(1, args.epochs_num + 1):
+        model.train()
+        for i, (src_batch, tgt_batch, seg_batch, soft_tgt_batch) in enumerate(batch_loader(batch_size, src, tgt, seg, soft_tgt)):
+            loss = train_model(args, model, optimizer, scheduler, src_batch, tgt_batch, seg_batch, soft_tgt_batch)
+            total_loss += loss.item()
+            if (i + 1) % args.report_steps == 0 and args.rank == 0:
+                args.logger.info("Epoch id: {}, Training steps: {}, Avg loss: {:.3f}".format(epoch, i + 1, total_loss / args.report_steps))
+                total_loss = 0.0
+        if args.rank == 0:
+            result = evaluate(args, read_dataset(args, args.dev_path, split=False))
+            result_tensor = torch.tensor(result[0]).to(args.device)
+        dist.broadcast(result_tensor, 0, async_op=False)
+        if result_tensor.float() >= best_result:
+            best_result = result_tensor.float().item()
+            best_epoch = epoch
+        model.save_checkpoint(args.output_model_path, str(epoch))
+
+    # Evaluation phase.
+    if args.test_path is not None and args.rank == 0:
+        args.logger.info("Test set evaluation.")
+        model.load_checkpoint(args.output_model_path, str(best_epoch))
+        evaluate(args, read_dataset(args, args.test_path, split=False), True)
+
+
+if __name__ == "__main__":
+    main()

train/finetune/run_classifier_grid.py

@@ -0,0 +1,120 @@
+"""
+This script provides an example to wrap TencentPretrain for classification with grid search.
+"""
+import sys
+import os
+import torch
+import random
+import argparse
+from itertools import product
+
+tencentpretrain_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(tencentpretrain_dir)
+
+from tencentpretrain.opts import *
+from finetune.run_classifier import *
+
+
+def main():
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    finetune_opts(parser)
+
+    tokenizer_opts(parser)
+
+    parser.add_argument("--soft_targets", action='store_true',
+                        help="Train model with logits.")
+    parser.add_argument("--soft_alpha", type=float, default=0.5,
+                        help="Weight of the soft targets loss.")
+
+    parser.add_argument("--batch_size_list", default=[32, 64], nargs='+', type=int,
+                        help="A list of batch sizes for grid search.")
+    parser.add_argument("--learning_rate_list", type=float, default=[3e-5, 1e-4, 3e-4], nargs='+',
+                        help="A list of learning rate for grid search.")
+    parser.add_argument("--epochs_num_list", type=int, default=[3, 5, 8], nargs='+',
+                        help="A list of number of epochs for grid search.")
+
+    adv_opts(parser)
+
+    args = parser.parse_args()
+
+    # Load the hyperparameters from the config file.
+    args = load_hyperparam(args)
+
+    set_seed(args.seed)
+
+    # Count the number of labels.
+    args.labels_num = count_labels_num(args.train_path)
+
+    # Build tokenizer.
+    args.tokenizer = str2tokenizer[args.tokenizer](args)
+
+    # Get logger.
+    args.logger = init_logger(args)
+
+    best_acc = 0
+    config = {}
+
+    # Build dataset
+    trainset = read_dataset(args, args.train_path)
+    instances_num = len(trainset)
+
+    for batch_size, learning_rate, epochs_num in product(args.batch_size_list, args.learning_rate_list, args.epochs_num_list):
+
+        args.learning_rate = learning_rate
+        args.batch_size = batch_size
+        args.epochs_num = epochs_num
+
+        args.train_steps = int(instances_num * args.epochs_num / batch_size) + 1
+
+        # Build classification model.
+        model = Classifier(args)
+
+        args.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        model = model.to(args.device)
+        load_or_initialize_parameters(args, model)
+        optimizer, scheduler = build_optimizer(args, model)
+        if args.fp16:
+            try:
+                from apex import amp
+            except ImportError:
+                raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
+            model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level)
+            args.amp = amp
+        if torch.cuda.device_count() > 1:
+            model = torch.nn.DataParallel(model)
+        args.model = model
+
+        if args.use_adv:
+            args.adv_method = str2adv[args.adv_type](model)
+
+        # Training phase.
+
+        total_loss, _, _ = 0., 0., 0.
+
+        for _ in range(1, args.epochs_num + 1):
+            random.shuffle(trainset)
+            src = torch.LongTensor([example[0] for example in trainset])
+            tgt = torch.LongTensor([example[1] for example in trainset])
+            seg = torch.LongTensor([example[2] for example in trainset])
+            if args.soft_targets:
+                soft_tgt = torch.FloatTensor([example[3] for example in trainset])
+            else:
+                soft_tgt = None
+
+            model.train()
+            for i, (src_batch, tgt_batch, seg_batch, soft_tgt_batch) in enumerate(batch_loader(batch_size, src, tgt, seg, soft_tgt)):
+                _ = train_model(args, model, optimizer, scheduler, src_batch, tgt_batch, seg_batch, soft_tgt_batch)
+
+        acc, _ = evaluate(args, read_dataset(args, args.dev_path))
+
+        if acc > best_acc:
+            best_acc = acc
+            config = {"learning_rate": learning_rate, "batch_size": batch_size, "epochs_num": epochs_num}
+        args.logger.info("On configuration: {}.\n".format(config))
+
+    args.logger.info("Best Acc. is: {:.4f}, on configuration {}.".format(best_acc, config))
+
+
+if __name__ == "__main__":
+    main()

train/finetune/run_classifier_mt.py

@@ -0,0 +1,203 @@
+"""
+This script provides an example to wrap TencentPretrain for multi-task classification.
+"""
+import sys
+import os
+import random
+import argparse
+import torch
+import torch.nn as nn
+
+tencentpretrain_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(tencentpretrain_dir)
+
+from tencentpretrain.embeddings import *
+from tencentpretrain.encoders import *
+from tencentpretrain.utils.constants import *
+from tencentpretrain.utils import *
+from tencentpretrain.utils.optimizers import *
+from tencentpretrain.utils.config import load_hyperparam
+from tencentpretrain.utils.seed import set_seed
+from tencentpretrain.utils.logging import init_logger
+from tencentpretrain.utils.misc import pooling
+from tencentpretrain.model_saver import save_model
+from tencentpretrain.opts import *
+from finetune.run_classifier import count_labels_num, batch_loader, build_optimizer, load_or_initialize_parameters, train_model, read_dataset, evaluate
+
+
+class MultitaskClassifier(nn.Module):
+    def __init__(self, args):
+        super(MultitaskClassifier, self).__init__()
+        self.embedding = Embedding(args)
+        for embedding_name in args.embedding:
+            tmp_emb = str2embedding[embedding_name](args, len(args.tokenizer.vocab))
+            self.embedding.update(tmp_emb, embedding_name)
+        self.encoder = str2encoder[args.encoder](args)
+        self.pooling_type = args.pooling
+        self.output_layers_1 = nn.ModuleList([nn.Linear(args.hidden_size, args.hidden_size) for _ in args.labels_num_list])
+        self.output_layers_2 = nn.ModuleList([nn.Linear(args.hidden_size, labels_num) for labels_num in args.labels_num_list])
+
+        self.dataset_id = 0
+
+    def forward(self, src, tgt, seg, soft_tgt=None):
+        """
+        Args:
+            src: [batch_size x seq_length]
+            tgt: [batch_size]
+            seg: [batch_size x seq_length]
+        """
+        # Embedding.
+        emb = self.embedding(src, seg)
+        # Encoder.
+        output = self.encoder(emb, seg)
+        # Target.
+        output = pooling(output, seg, self.pooling_type)
+        output = torch.tanh(self.output_layers_1[self.dataset_id](output))
+        logits = self.output_layers_2[self.dataset_id](output)
+        if tgt is not None:
+            loss = nn.NLLLoss()(nn.LogSoftmax(dim=-1)(logits), tgt.view(-1))
+            return loss, logits
+        else:
+            return None, logits
+
+    def change_dataset(self, dataset_id):
+        self.dataset_id = dataset_id
+
+
+def pack_dataset(dataset, dataset_id, batch_size):
+    packed_dataset = []
+    src_batch, tgt_batch, seg_batch = [], [], []
+    for i, sample in enumerate(dataset):
+        src_batch.append(sample[0])
+        tgt_batch.append(sample[1])
+        seg_batch.append(sample[2])
+        if (i + 1) % batch_size == 0:
+            packed_dataset.append((dataset_id, torch.LongTensor(src_batch), torch.LongTensor(tgt_batch), torch.LongTensor(seg_batch)))
+            src_batch, tgt_batch, seg_batch = [], [], []
+            continue
+    if len(src_batch) > 0:
+        packed_dataset.append((dataset_id, torch.LongTensor(src_batch), torch.LongTensor(tgt_batch), torch.LongTensor(seg_batch)))
+
+    return packed_dataset
+
+
+def main():
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    # Path options.
+    parser.add_argument("--pretrained_model_path", default=None, type=str,
+                        help="Path of the pretrained model.")
+    parser.add_argument("--dataset_path_list", default=[], nargs='+', type=str, help="Dataset path list.")
+    parser.add_argument("--output_model_path", default="models/multitask_classifier_model.bin", type=str,
+                        help="Path of the output model.")
+    parser.add_argument("--config_path", default="models/bert/base_config.json", type=str,
+                        help="Path of the config file.")
+
+    # Model options.
+    model_opts(parser)
+
+    # Tokenizer options.
+    tokenizer_opts(parser)
+
+    # Optimizer options.
+    optimization_opts(parser)
+
+    # Training options.
+    training_opts(parser)
+
+    adv_opts(parser)
+
+    args = parser.parse_args()
+
+    args.soft_targets = False
+
+    # Load the hyperparameters from the config file.
+    args = load_hyperparam(args)
+
+    set_seed(args.seed)
+
+    # Count the number of labels.
+    args.labels_num_list = [count_labels_num(os.path.join(path, "train.tsv")) for path in args.dataset_path_list]
+
+    args.datasets_num = len(args.dataset_path_list)
+
+    # Build tokenizer.
+    args.tokenizer = str2tokenizer[args.tokenizer](args)
+
+    # Build multi-task classification model.
+    model = MultitaskClassifier(args)
+
+    # Load or initialize parameters.
+    load_or_initialize_parameters(args, model)
+
+    # Get logger.
+    args.logger = init_logger(args)
+
+    args.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(args.device)
+    args.model = model
+
+    if args.use_adv:
+        args.adv_method = str2adv[args.adv_type](model)
+
+    # Training phase.
+    dataset_list = [read_dataset(args, os.path.join(path, "train.tsv")) for path in args.dataset_path_list]
+    packed_dataset_list = [pack_dataset(dataset, i, args.batch_size) for i, dataset in enumerate(dataset_list)]
+
+    packed_dataset_all = []
+    for packed_dataset in packed_dataset_list:
+        packed_dataset_all += packed_dataset
+
+    instances_num = sum([len(dataset) for dataset in dataset_list])
+    batch_size = args.batch_size
+
+    args.train_steps = int(instances_num * args.epochs_num / batch_size) + 1
+
+    args.logger.info("Batch size: {}".format(batch_size))
+    args.logger.info("The number of training instances: {}".format(instances_num))
+
+    optimizer, scheduler = build_optimizer(args, model)
+
+    if args.fp16:
+        try:
+            from apex import amp
+        except ImportError:
+            raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
+        model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level)
+        args.amp = amp
+
+    if torch.cuda.device_count() > 1:
+        args.logger.info("{} GPUs are available. Let's use them.".format(torch.cuda.device_count()))
+        model = torch.nn.DataParallel(model)
+
+    total_loss, result, best_result = 0.0, 0.0, 0.0
+
+    args.logger.info("Start training.")
+
+    for epoch in range(1, args.epochs_num + 1):
+        random.shuffle(packed_dataset_all)
+        model.train()
+        for i, (dataset_id, src_batch, tgt_batch, seg_batch) in enumerate(packed_dataset_all):
+            if hasattr(model, "module"):
+                model.module.change_dataset(dataset_id)
+            else:
+                model.change_dataset(dataset_id)
+            loss = train_model(args, model, optimizer, scheduler, src_batch, tgt_batch, seg_batch, None)
+            total_loss += loss.item()
+            if (i + 1) % args.report_steps == 0:
+                args.logger.info("Epoch id: {}, Training steps: {}, Avg loss: {:.3f}".format(epoch, i + 1, total_loss / args.report_steps))
+                total_loss = 0.0
+
+        for dataset_id, path in enumerate(args.dataset_path_list):
+            args.labels_num = args.labels_num_list[dataset_id]
+            if hasattr(model, "module"):
+                model.module.change_dataset(dataset_id)
+            else:
+                model.change_dataset(dataset_id)
+            result = evaluate(args, read_dataset(args, os.path.join(path, "dev.tsv")))
+
+    save_model(model, args.output_model_path)
+
+
+if __name__ == "__main__":
+    main()

train/finetune/run_classifier_multi_label.py

@@ -0,0 +1,287 @@
+"""
+This script provides an example to wrap TencentPretrain for multi-label classification.
+"""
+import sys
+import os
+import random
+import argparse
+import torch
+import torch.nn as nn
+import time
+import datetime
+import json
+
+tencentpretrain_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(tencentpretrain_dir)
+
+from tencentpretrain.embeddings import *
+from tencentpretrain.encoders import *
+from tencentpretrain.utils.vocab import Vocab
+from tencentpretrain.utils.constants import *
+from tencentpretrain.utils import *
+from tencentpretrain.utils.optimizers import *
+from tencentpretrain.utils.config import load_hyperparam
+from tencentpretrain.utils.seed import set_seed
+from tencentpretrain.utils.logging import init_logger
+from tencentpretrain.utils.misc import pooling
+from tencentpretrain.model_saver import save_model
+from tencentpretrain.opts import finetune_opts, tokenizer_opts, adv_opts
+from finetune.run_classifier import load_or_initialize_parameters, build_optimizer, batch_loader
+
+
+class MultilabelClassifier(nn.Module):
+    def __init__(self, args):
+        super(MultilabelClassifier, self).__init__()
+        self.embedding = Embedding(args)
+        for embedding_name in args.embedding:
+            tmp_emb = str2embedding[embedding_name](args, len(args.tokenizer.vocab))
+            self.embedding.update(tmp_emb, embedding_name)
+        self.encoder = str2encoder[args.encoder](args)
+        self.labels_num = args.labels_num
+        self.pooling_type = args.pooling
+        self.output_layer_1 = nn.Linear(args.hidden_size, args.hidden_size)
+        self.output_layer_2 = nn.Linear(args.hidden_size, self.labels_num)
+
+    def forward(self, src, tgt, seg):
+        """
+        Args:
+            src: [batch_size x seq_length]
+            tgt: [batch_size]
+            seg: [batch_size x seq_length]
+        """
+        # Embedding.
+        emb = self.embedding(src, seg)
+        # Encoder.
+        output = self.encoder(emb, seg)
+        # Target.
+        output = pooling(output, seg, self.pooling_type)
+        output = torch.tanh(self.output_layer_1(output))
+        logits = self.output_layer_2(output)
+        if tgt is not None:
+            probs_batch = nn.Sigmoid()(logits)
+            loss = nn.BCELoss()(probs_batch, tgt)
+            return loss, logits
+        else:
+            return None, logits
+
+
+def count_labels_num(path):
+    labels_set, columns = set(), {}
+    with open(path, mode="r", encoding="utf-8") as f:
+        for line_id, line in enumerate(f):
+            if line_id == 0:
+                for i, column_name in enumerate(line.rstrip("\r\n").split("\t")):
+                    columns[column_name] = i
+                continue
+            line = line.rstrip("\r\n").split("\t")
+            label = set(line[columns["label"]].split(","))
+            labels_set |= label
+    return len(labels_set)
+
+
+def read_dataset(args, path):
+    dataset, columns = [], {}
+    with open(path, mode="r", encoding="utf-8") as f:
+        for line_id, line in enumerate(f):
+            if line_id == 0:
+                for i, column_name in enumerate(line.rstrip("\r\n").split("\t")):
+                    columns[column_name] = i
+                continue
+            line = line.rstrip("\r\n").split("\t")
+            tgt = [0] * args.labels_num
+            for idx in [int(_) for _ in line[columns["label"]].split(",")]:
+                tgt[idx] = 1
+            if "text_b" not in columns:  # Sentence classification.
+                text_a = line[columns["text_a"]]
+                src = args.tokenizer.convert_tokens_to_ids([CLS_TOKEN] + args.tokenizer.tokenize(text_a) + [SEP_TOKEN])
+                seg = [1] * len(src)
+            else:  # Sentence-pair classification.
+                text_a, text_b = line[columns["text_a"]], line[columns["text_b"]]
+                src_a = args.tokenizer.convert_tokens_to_ids([CLS_TOKEN] + args.tokenizer.tokenize(text_a) + [SEP_TOKEN])
+                src_b = args.tokenizer.convert_tokens_to_ids(args.tokenizer.tokenize(text_b) + [SEP_TOKEN])
+                src = src_a + src_b
+                seg = [1] * len(src_a) + [2] * len(src_b)
+
+            if len(src) > args.seq_length:
+                src = src[: args.seq_length]
+                seg = seg[: args.seq_length]
+            PAD_ID = args.tokenizer.convert_tokens_to_ids([PAD_TOKEN])[0]
+            while len(src) < args.seq_length:
+                src.append(PAD_ID)
+                seg.append(0)
+
+            dataset.append((src, tgt, seg))
+
+    return dataset
+
+
+def train_model(args, model, optimizer, scheduler, src_batch, tgt_batch, seg_batch):
+    model.zero_grad()
+
+    src_batch = src_batch.to(args.device)
+    tgt_batch = tgt_batch.to(args.device)
+    seg_batch = seg_batch.to(args.device)
+
+    loss, _ = model(src_batch, tgt_batch, seg_batch)
+    if torch.cuda.device_count() > 1:
+        loss = torch.mean(loss)
+
+    if args.fp16:
+        with args.amp.scale_loss(loss, optimizer) as scaled_loss:
+            scaled_loss.backward()
+    else:
+        loss.backward()
+
+    if args.use_adv and args.adv_type == "fgm":
+        args.adv_method.attack(epsilon=args.fgm_epsilon)
+        loss_adv, _ = model(src_batch, tgt_batch, seg_batch)
+        if torch.cuda.device_count() > 1:
+            loss_adv = torch.mean(loss_adv)
+        loss_adv.backward()
+        args.adv_method.restore()
+
+    if args.use_adv and args.adv_type == "pgd":
+        K = args.pgd_k
+        args.adv_method.backup_grad()
+        for t in range(K):
+            # apply the perturbation to embedding
+            args.adv_method.attack(epsilon=args.pgd_epsilon, alpha=args.pgd_alpha,
+                                   is_first_attack=(t == 0))
+            if t != K - 1:
+                model.zero_grad()
+            else:
+                args.adv_method.restore_grad()
+            loss_adv, _ = model(src_batch, tgt_batch, seg_batch)
+            if torch.cuda.device_count() > 1:
+                loss_adv = torch.mean(loss_adv)
+            loss_adv.backward()
+        args.adv_method.restore()
+
+    optimizer.step()
+    scheduler.step()
+
+    return loss
+
+
+def evaluate(args, dataset):
+    src = torch.LongTensor([sample[0] for sample in dataset])
+    tgt = torch.tensor([sample[1] for sample in dataset], dtype=torch.float)
+    seg = torch.LongTensor([sample[2] for sample in dataset])
+
+    batch_size = args.batch_size
+
+    correct = 0
+
+    args.model.eval()
+
+    for i, (src_batch, tgt_batch, seg_batch, _) in enumerate(batch_loader(batch_size, src, tgt, seg)):
+        src_batch = src_batch.to(args.device)
+        tgt_batch = tgt_batch.to(args.device)
+        seg_batch = seg_batch.to(args.device)
+        with torch.no_grad():
+            _, logits = args.model(src_batch, tgt_batch, seg_batch)
+        probs_batch = nn.Sigmoid()(logits)
+        predict_label_batch = (probs_batch > 0.5).float()
+        gold = tgt_batch
+
+        for k in range(len(predict_label_batch)):
+            correct += predict_label_batch[k].equal(gold[k])
+
+    args.logger.info("Acc. (Correct/Total): {:.4f} ({}/{}) ".format(correct / len(dataset), correct, len(dataset)))
+    return correct / len(dataset)
+
+
+def main():
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    finetune_opts(parser)
+
+    tokenizer_opts(parser)
+
+    adv_opts(parser)
+
+    args = parser.parse_args()
+
+    # Load the hyperparameters from the config file.
+    args = load_hyperparam(args)
+    # Count the number of labels.
+    args.labels_num = count_labels_num(args.train_path)
+
+    # Build tokenizer.
+    args.tokenizer = str2tokenizer[args.tokenizer](args)
+    set_seed(args.seed)
+
+    # Build classification model.
+    model = MultilabelClassifier(args)
+
+    # Load or initialize parameters.
+    load_or_initialize_parameters(args, model)
+
+    # Get logger.
+    args.logger = init_logger(args)
+
+    args.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(args.device)
+
+    # Training phase.
+    trainset = read_dataset(args, args.train_path)
+    instances_num = len(trainset)
+    batch_size = args.batch_size
+
+    args.train_steps = int(instances_num * args.epochs_num / batch_size) + 1
+
+    args.logger.info("Batch size: {}".format(batch_size))
+    args.logger.info("The number of training instances: {}".format(instances_num))
+    optimizer, scheduler = build_optimizer(args, model)
+
+    if args.fp16:
+        try:
+            from apex import amp
+        except ImportError:
+            raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
+        model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level)
+        args.amp = amp
+
+    if torch.cuda.device_count() > 1:
+        args.logger.info("{} GPUs are available. Let's use them.".format(torch.cuda.device_count()))
+        model = torch.nn.DataParallel(model)
+    args.model = model
+
+    if args.use_adv:
+        args.adv_method = str2adv[args.adv_type](model)
+
+    total_loss, result, best_result = 0.0, 0.0, 0.0
+
+    args.logger.info("Start training.")
+
+    for epoch in range(1, args.epochs_num + 1):
+        random.shuffle(trainset)
+        src = torch.LongTensor([example[0] for example in trainset])
+        tgt = torch.tensor([sample[1] for sample in trainset], dtype=torch.float)
+        seg = torch.LongTensor([example[2] for example in trainset])
+
+        model.train()
+        for i, (src_batch, tgt_batch, seg_batch, _) in enumerate(batch_loader(batch_size, src, tgt, seg)):
+            loss = train_model(args, model, optimizer, scheduler, src_batch, tgt_batch, seg_batch)
+            total_loss += loss.item()
+            if (i + 1) % args.report_steps == 0:
+                args.logger.info("Epoch id: {}, Training steps: {}, Avg loss: {:.3f}".format(epoch, i + 1, total_loss / args.report_steps))
+                total_loss = 0.0
+
+        result = evaluate(args, read_dataset(args, args.dev_path))
+        if result > best_result:
+            best_result = result
+            save_model(model, args.output_model_path)
+
+    # Evaluation phase.
+    if args.test_path is not None:
+        args.logger.info("Test set evaluation.")
+        if torch.cuda.device_count() > 1:
+            args.model.module.load_state_dict(torch.load(args.output_model_path))
+        else:
+            args.model.load_state_dict(torch.load(args.output_model_path))
+        evaluate(args, read_dataset(args, args.test_path))
+
+
+if __name__ == "__main__":
+    main()

train/finetune/run_classifier_prompt.py

@@ -0,0 +1,308 @@
+"""
+This script provides an example to use prompt for classification.
+"""
+import re
+import sys
+import os
+import logging
+import random
+import argparse
+import torch
+import torch.nn as nn
+
+tencentpretrain_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(tencentpretrain_dir)
+
+from finetune.run_classifier import *
+from tencentpretrain.targets import *
+
+
+class ClozeTest(nn.Module):
+    def __init__(self, args):
+        super(ClozeTest, self).__init__()
+        self.embedding = Embedding(args)
+        for embedding_name in args.embedding:
+            tmp_emb = str2embedding[embedding_name](args, len(args.tokenizer.vocab))
+            self.embedding.update(tmp_emb, embedding_name)
+        self.encoder = str2encoder[args.encoder](args)
+        self.target = MlmTarget(args, len(args.tokenizer.vocab))
+        if args.tie_weights:
+            self.target.mlm_linear_2.weight = self.embedding.word_embedding.weight
+        self.answer_position = args.answer_position
+        self.device = args.device
+
+    def forward(self, src, tgt, seg):
+        emb = self.embedding(src, seg)
+        memory_bank = self.encoder(emb, seg)
+        output_mlm = self.target.act(self.target.mlm_linear_1(memory_bank))
+        output_mlm = self.target.layer_norm(output_mlm)
+        tgt_mlm = tgt.contiguous().view(-1)
+        if self.target.factorized_embedding_parameterization:
+            output_mlm = output_mlm.contiguous().view(-1, self.target.emb_size)
+        else:
+            output_mlm = output_mlm.contiguous().view(-1, self.target.hidden_size)
+        output_mlm = output_mlm[tgt_mlm > 0, :]
+        tgt_mlm = tgt_mlm[tgt_mlm > 0]
+        self.answer_position = self.answer_position.to(self.device).view(-1)
+        logits = self.target.mlm_linear_2(output_mlm)
+        logits = logits * self.answer_position
+        prob = self.target.softmax(logits)
+        loss = self.target.criterion(prob, tgt_mlm)
+        pred = prob[:, self.answer_position > 0].argmax(dim=-1)
+
+        return loss, pred, logits
+
+
+def read_dataset(args, path):
+    dataset, columns = [], {}
+    count, ignore_count = 0, 0
+    with open(path, mode="r", encoding="utf-8") as f:
+        for line_id, line in enumerate(f):
+            if line_id == 0:
+                for i, column_name in enumerate(line.rstrip("\r\n").split("\t")):
+                    columns[column_name] = i
+                continue
+            line = line.rstrip("\r\n").split("\t")
+            mask_position = -1
+            label = args.answer_word_dict[str(line[columns["label"]])]
+            tgt_token_id = args.tokenizer.vocab[label]
+            src = [args.tokenizer.vocab.get(CLS_TOKEN)]
+            if "text_b" not in columns:  # Sentence classification.
+                text_a = line[columns["text_a"]]
+                text_a_token_id = args.tokenizer.convert_tokens_to_ids(args.tokenizer.tokenize(text_a))
+                max_length = args.seq_length - args.template_length - 2
+                text_a_token_id = text_a_token_id[:max_length]
+                for prompt_token in args.prompt_template:
+                    if prompt_token == "[TEXT_A]":
+                        src += text_a_token_id
+                    elif prompt_token == "[ANS]":
+                        src += [args.tokenizer.vocab.get(MASK_TOKEN)]
+                        mask_position = len(src) - 1
+                    else:
+                        src += prompt_token
+            else:  # Sentence-pair classification.
+                text_a, text_b = line[columns["text_a"]], line[columns["text_b"]]
+                text_a_token_id = args.tokenizer.convert_tokens_to_ids(args.tokenizer.tokenize(text_a))
+                text_b_token_id = args.tokenizer.convert_tokens_to_ids(args.tokenizer.tokenize(text_b))
+                max_length = args.seq_length - args.template_length - len(text_a_token_id) - 3
+                text_b_token_id = text_b_token_id[:max_length]
+                for prompt_token in args.prompt_template:
+                    if prompt_token == "[TEXT_A]":
+                        src += text_a_token_id
+                        src += [args.tokenizer.vocab.get(SEP_TOKEN)]
+                    elif prompt_token == "[ANS]":
+                        src += [args.tokenizer.vocab.get(MASK_TOKEN)]
+                        mask_position = len(src) - 1
+                    elif prompt_token == "[TEXT_B]":
+                        src += text_b_token_id
+                    else:
+                        src += prompt_token
+            src += [args.tokenizer.vocab.get(SEP_TOKEN)]
+            seg = [1] * len(src)
+
+            if len(src) > args.seq_length:
+                src = src[: args.seq_length]
+                seg = seg[: args.seq_length]
+
+            PAD_ID = args.tokenizer.convert_tokens_to_ids([PAD_TOKEN])[0]
+            while len(src) < args.seq_length:
+                src.append(PAD_ID)
+                seg.append(0)
+            tgt = [0] * len(src)
+            # Ignore the sentence which the answer is not in a sequence
+            if mask_position >= args.seq_length:
+                ignore_count += 1
+                continue
+            tgt[mask_position] = tgt_token_id
+            count += 1
+            dataset.append((src, tgt, seg))
+        args.logger.info(f"read dataset, count:{count}, ignore_count:{ignore_count}")
+    return dataset
+
+
+def train_model(args, model, optimizer, scheduler, src_batch, tgt_batch, seg_batch):
+    model.zero_grad()
+
+    src_batch = src_batch.to(args.device)
+    tgt_batch = tgt_batch.to(args.device)
+    seg_batch = seg_batch.to(args.device)
+
+    loss, _, _ = model(src_batch, tgt_batch, seg_batch)
+    if torch.cuda.device_count() > 1:
+        loss = torch.mean(loss)
+
+    if args.fp16:
+        with args.amp.scale_loss(loss, optimizer) as scaled_loss:
+            scaled_loss.backward()
+    else:
+        loss.backward()
+
+    optimizer.step()
+    scheduler.step()
+
+    return loss
+
+
+def process_prompt_template(args):
+    with open(args.prompt_path, "r", encoding="utf-8") as f_json:
+        temp_dict = json.load(f_json)
+        template_str = temp_dict[args.prompt_id]["template"]
+        template_list = re.split(r"(\[TEXT_B\]|\[TEXT_A\]|\[ANS\])", template_str)
+        args.prompt_template = []
+        template_length = 0
+        for term in template_list:
+            if len(term) > 0:
+                if term not in ["[TEXT_B]", "[TEXT_A]", "[ANS]"]:
+                    term_tokens = args.tokenizer.convert_tokens_to_ids(args.tokenizer.tokenize(term))
+                    args.prompt_template.append(term_tokens)
+                    template_length += len(term_tokens)
+                elif term in ["[TEXT_B]", "[TEXT_A]"]:
+                    args.prompt_template.append(term)
+                else:
+                    args.prompt_template.append(term)
+                    template_length += 1
+        print(args.prompt_template)
+        args.answer_word_dict = temp_dict[args.prompt_id]["answer_words"]
+        args.answer_word_dict_inv = {v: k for k, v in args.answer_word_dict.items()}
+        args.template_length = template_length
+
+
+def evaluate(args, dataset):
+    src = torch.LongTensor([sample[0] for sample in dataset])
+    tgt = torch.LongTensor([sample[1] for sample in dataset])
+    seg = torch.LongTensor([sample[2] for sample in dataset])
+
+    batch_size = args.batch_size
+
+    correct = 0
+    labels = {}
+    for k in sorted([args.tokenizer.vocab[k] for k in args.answer_word_dict_inv]):
+        labels[k] = len(labels)
+    labels_inv = {v: k for k, v in labels.items()}
+    confusion = torch.zeros(len(labels), len(labels), dtype=torch.long)
+    args.model.eval()
+
+    for i, (src_batch, tgt_batch, seg_batch, _) in enumerate(batch_loader(batch_size, src, tgt, seg)):
+        src_batch = src_batch.to(args.device)
+        tgt_batch = tgt_batch.to(args.device)
+        seg_batch = seg_batch.to(args.device)
+
+        with torch.no_grad():
+            _, pred, _ = args.model(src_batch, tgt_batch, seg_batch)
+        gold = tgt_batch[tgt_batch > 0]
+        for j in range(pred.size()[0]):
+            pred[j] = labels_inv[int(pred[j])]
+            confusion[labels[int(pred[j])], labels[int(gold[j])]] += 1
+        correct += torch.sum(pred == gold).item()
+
+    args.logger.debug("Confusion matrix:")
+    args.logger.debug(confusion)
+    args.logger.debug("Report precision, recall, and f1:")
+
+    eps = 1e-9
+    for i in range(confusion.size()[0]):
+        p = confusion[i, i].item() / (confusion[i, :].sum().item() + eps)
+        r = confusion[i, i].item() / (confusion[:, i].sum().item() + eps)
+        f1 = 2 * p * r / (p + r + eps)
+        args.logger.debug("Label {}: {:.3f}, {:.3f}, {:.3f}".format(i, p, r, f1))
+
+    args.logger.info("Acc. (Correct/Total): {:.4f} ({}/{}) ".format(correct / len(dataset), correct, len(dataset)))
+    return correct / len(dataset), confusion
+
+
+def main():
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    tokenizer_opts(parser)
+    finetune_opts(parser)
+
+    parser.add_argument("--prompt_id", type=str, default="chnsenticorp_char")
+    parser.add_argument("--prompt_path", type=str, default="models/prompts.json")
+
+    args = parser.parse_args()
+
+    # Load the hyperparameters from the config file.
+    args = load_hyperparam(args)
+
+    args.tokenizer = str2tokenizer[args.tokenizer](args)
+    set_seed(args.seed)
+
+    process_prompt_template(args)
+
+    args.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    answer_position = [0] * len(args.tokenizer.vocab)
+    for answer in args.answer_word_dict_inv:
+        answer_position[int(args.tokenizer.vocab[answer])] = 1
+    args.answer_position = torch.LongTensor(answer_position)
+    # Build classification model.
+    model = ClozeTest(args)
+
+    # Load or initialize parameters.
+    load_or_initialize_parameters(args, model)
+
+    # Get logger.
+    args.logger = init_logger(args)
+
+    model = model.to(args.device)
+
+    # Training phase.
+    trainset = read_dataset(args, args.train_path)
+
+    instances_num = len(trainset)
+    batch_size = args.batch_size
+
+    args.train_steps = int(instances_num * args.epochs_num / batch_size) + 1
+
+    args.logger.info("Batch size: {}".format(batch_size))
+    args.logger.info("The number of training instances: {}".format(instances_num))
+    optimizer, scheduler = build_optimizer(args, model)
+
+    if args.fp16:
+        try:
+            from apex import amp
+        except ImportError:
+            raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
+        model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level)
+        args.amp = amp
+
+    if torch.cuda.device_count() > 1:
+        args.logger.info("{} GPUs are available. Let's use them.".format(torch.cuda.device_count()))
+        model = torch.nn.DataParallel(model)
+    args.model = model
+
+    total_loss, result, best_result = 0.0, 0.0, 0.0
+
+    args.logger.info("Start training.")
+    for epoch in range(1, args.epochs_num + 1):
+        random.shuffle(trainset)
+        src = torch.LongTensor([example[0] for example in trainset])
+        tgt = torch.LongTensor([example[1] for example in trainset])
+        seg = torch.LongTensor([example[2] for example in trainset])
+
+        model.train()
+        for i, (src_batch, tgt_batch, seg_batch, _) in enumerate(batch_loader(batch_size, src, tgt, seg, None)):
+            loss = train_model(args, model, optimizer, scheduler, src_batch, tgt_batch, seg_batch)
+            total_loss += loss.item()
+            if (i + 1) % args.report_steps == 0:
+                args.logger.info("Epoch id: {}, Training steps: {}, Avg loss: {:.3f}".format(epoch, i + 1, total_loss / args.report_steps))
+                total_loss = 0.0
+
+        result = evaluate(args, read_dataset(args, args.dev_path))
+        if result[0] > best_result:
+            best_result = result[0]
+            save_model(model, args.output_model_path)
+
+    # Evaluation phase.
+    if args.epochs_num == 0:
+        args.output_model_path = args.pretrained_model_path
+    if args.test_path is not None:
+        args.logger.info("Test set evaluation.")
+        if torch.cuda.device_count() > 1:
+            args.model.module.load_state_dict(torch.load(args.output_model_path), strict=False)
+        else:
+            args.model.load_state_dict(torch.load(args.output_model_path), strict=False)
+        evaluate(args, read_dataset(args, args.test_path))
+
+
+if __name__ == "__main__":
+    main()

train/finetune/run_classifier_siamese.py

@@ -0,0 +1,340 @@
+"""
+This script provides an example to wrap TencentPretrain for classification with siamese network.
+"""
+import sys
+import os
+import random
+import argparse
+import collections
+import torch
+import torch.nn as nn
+
+tencentpretrain_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(tencentpretrain_dir)
+
+from tencentpretrain.embeddings import *
+from tencentpretrain.encoders import *
+from tencentpretrain.targets import *
+from tencentpretrain.utils.vocab import Vocab
+from tencentpretrain.utils.constants import *
+from tencentpretrain.utils import *
+from tencentpretrain.utils.optimizers import *
+from tencentpretrain.utils.config import load_hyperparam
+from tencentpretrain.utils.seed import set_seed
+from tencentpretrain.utils.logging import init_logger
+from tencentpretrain.utils.misc import pooling
+from tencentpretrain.model_saver import save_model
+from tencentpretrain.opts import finetune_opts, tokenizer_opts
+from finetune.run_classifier import count_labels_num, build_optimizer
+
+
+class SiameseClassifier(nn.Module):
+    def __init__(self, args):
+        super(SiameseClassifier, self).__init__()
+        self.embedding = Embedding(args)
+        for embedding_name in args.embedding:
+            tmp_emb = str2embedding[embedding_name](args, len(args.tokenizer.vocab))
+            self.embedding.update(tmp_emb, embedding_name)
+        self.encoder = DualEncoder(args)
+
+        self.classifier = nn.Linear(4 * args.stream_0["hidden_size"], args.labels_num)
+        self.pooling_type = args.pooling
+
+    def forward(self, src, tgt, seg):
+        """
+        Args:
+            src: [batch_size x seq_length]
+            tgt: [batch_size]
+            seg: [batch_size x seq_length]
+        """
+        # Embedding.
+        emb = self.embedding(src, seg)
+        # Encoder.
+        output = self.encoder(emb, seg)
+        # Target.
+        features_0, features_1 = output
+        features_0 = pooling(features_0, seg[0], self.pooling_type)
+        features_1 = pooling(features_1, seg[1], self.pooling_type)
+
+        vectors_concat = []
+
+        # concatenation
+        vectors_concat.append(features_0)
+        vectors_concat.append(features_1)
+        # difference:
+        vectors_concat.append(torch.abs(features_0 - features_1))
+        # multiplication:
+        vectors_concat.append(features_0 * features_1)
+
+        features = torch.cat(vectors_concat, 1)
+
+        logits = self.classifier(features)
+
+        if tgt is not None:
+            loss = nn.NLLLoss()(nn.LogSoftmax(dim=-1)(logits), tgt.view(-1))
+            return loss, logits
+        else:
+            return None, logits
+
+
+def load_or_initialize_parameters(args, model):
+    if args.pretrained_model_path is not None:
+        # Initialize with pretrained model.
+        state_dict = torch.load(args.pretrained_model_path, map_location="cpu")
+        load_siamese_weights = False
+        for key in state_dict.keys():
+            if key.find("embedding_0") != -1:
+                load_siamese_weights = True
+                break
+        if not load_siamese_weights:
+            siamese_state_dict = collections.OrderedDict()
+            for key in state_dict.keys():
+                if key.split('.')[0] == "embedding":
+                    siamese_state_dict["embedding.embedding_0." + ".".join(key.split('.')[1:])] = state_dict[key]
+                    siamese_state_dict["embedding.embedding_1." + ".".join(key.split('.')[1:])] = state_dict[key]
+                if key.split('.')[0] == "encoder":
+                    siamese_state_dict["encoder.encoder_0." + ".".join(key.split('.')[1:])] = state_dict[key]
+                    siamese_state_dict["encoder.encoder_1." + ".".join(key.split('.')[1:])] = state_dict[key]
+            model.load_state_dict(siamese_state_dict, strict=False)
+        else:
+            model.load_state_dict(state_dict, strict=False)
+    else:
+        # Initialize with normal distribution.
+        for n, p in list(model.named_parameters()):
+            if "gamma" not in n and "beta" not in n:
+                p.data.normal_(0, 0.02)
+
+
+def batch_loader(batch_size, src, tgt, seg):
+    instances_num = tgt.size()[0]
+    src_a, src_b = src
+    seg_a, seg_b = seg
+    for i in range(instances_num // batch_size):
+        src_a_batch = src_a[i * batch_size : (i + 1) * batch_size, :]
+        src_b_batch = src_b[i * batch_size : (i + 1) * batch_size, :]
+        tgt_batch = tgt[i * batch_size : (i + 1) * batch_size]
+        seg_a_batch = seg_a[i * batch_size : (i + 1) * batch_size, :]
+        seg_b_batch = seg_b[i * batch_size : (i + 1) * batch_size, :]
+        yield (src_a_batch, src_b_batch), tgt_batch, (seg_a_batch, seg_b_batch)
+    if instances_num > instances_num // batch_size * batch_size:
+        src_a_batch = src_a[instances_num // batch_size * batch_size :, :]
+        src_b_batch = src_b[instances_num // batch_size * batch_size :, :]
+        tgt_batch = tgt[instances_num // batch_size * batch_size :]
+        seg_a_batch = seg_a[instances_num // batch_size * batch_size :, :]
+        seg_b_batch = seg_b[instances_num // batch_size * batch_size :, :]
+        yield (src_a_batch, src_b_batch), tgt_batch, (seg_a_batch, seg_b_batch)
+
+
+def read_dataset(args, path):
+    dataset, columns = [], {}
+    with open(path, mode="r", encoding="utf-8") as f:
+        for line_id, line in enumerate(f):
+            if line_id == 0:
+                for i, column_name in enumerate(line.rstrip("\r\n").split("\t")):
+                    columns[column_name] = i
+                continue
+            line = line.rstrip("\r\n").split("\t")
+            tgt = int(line[columns["label"]])
+
+            text_a, text_b = line[columns["text_a"]], line[columns["text_b"]]
+            src_a = args.tokenizer.convert_tokens_to_ids([CLS_TOKEN] + args.tokenizer.tokenize(text_a) + [SEP_TOKEN])
+            src_b = args.tokenizer.convert_tokens_to_ids([CLS_TOKEN] + args.tokenizer.tokenize(text_b) + [SEP_TOKEN])
+            seg_a = [1] * len(src_a)
+            seg_b = [1] * len(src_b)
+            PAD_ID = args.tokenizer.convert_tokens_to_ids([PAD_TOKEN])[0]
+
+            if len(src_a) >= args.seq_length:
+                src_a = src_a[:args.seq_length]
+                seg_a = seg_a[:args.seq_length]
+            while len(src_a) < args.seq_length:
+                src_a.append(PAD_ID)
+                seg_a.append(0)
+
+            if len(src_b) >= args.seq_length:
+                src_b = src_b[:args.seq_length]
+                seg_b = seg_b[:args.seq_length]
+            while len(src_b) < args.seq_length:
+                src_b.append(PAD_ID)
+                seg_b.append(0)
+
+            dataset.append(((src_a, src_b), tgt, (seg_a, seg_b)))
+
+    return dataset
+
+
+def train_model(args, model, optimizer, scheduler, src_batch, tgt_batch, seg_batch):
+    model.zero_grad()
+
+    src_a_batch, src_b_batch = src_batch
+    seg_a_batch, seg_b_batch = seg_batch
+
+    src_a_batch = src_a_batch.to(args.device)
+    src_b_batch = src_b_batch.to(args.device)
+
+    tgt_batch = tgt_batch.to(args.device)
+
+    seg_a_batch = seg_a_batch.to(args.device)
+    seg_b_batch = seg_b_batch.to(args.device)
+
+    loss, _ = model((src_a_batch, src_b_batch), tgt_batch, (seg_a_batch, seg_b_batch))
+
+    if torch.cuda.device_count() > 1:
+        loss = torch.mean(loss)
+
+    if args.fp16:
+        with args.amp.scale_loss(loss, optimizer) as scaled_loss:
+            scaled_loss.backward()
+    else:
+        loss.backward()
+
+    optimizer.step()
+    scheduler.step()
+
+    return loss
+
+
+def evaluate(args, dataset):
+    src_a = torch.LongTensor([example[0][0] for example in dataset])
+    src_b = torch.LongTensor([example[0][1] for example in dataset])
+    tgt = torch.LongTensor([example[1] for example in dataset])
+    seg_a = torch.LongTensor([example[2][0] for example in dataset])
+    seg_b = torch.LongTensor([example[2][1] for example in dataset])
+
+    batch_size = args.batch_size
+
+    correct = 0
+    # Confusion matrix.
+    confusion = torch.zeros(args.labels_num, args.labels_num, dtype=torch.long)
+
+    args.model.eval()
+
+    for i, (src_batch, tgt_batch, seg_batch) in enumerate(batch_loader(batch_size, (src_a, src_b), tgt, (seg_a, seg_b))):
+
+        src_a_batch, src_b_batch = src_batch
+        seg_a_batch, seg_b_batch = seg_batch
+
+        src_a_batch = src_a_batch.to(args.device)
+        src_b_batch = src_b_batch.to(args.device)
+
+        tgt_batch = tgt_batch.to(args.device)
+
+        seg_a_batch = seg_a_batch.to(args.device)
+        seg_b_batch = seg_b_batch.to(args.device)
+
+        with torch.no_grad():
+            _, logits = args.model((src_a_batch, src_b_batch), None, (seg_a_batch, seg_b_batch))
+        pred = torch.argmax(nn.Softmax(dim=1)(logits), dim=1)
+        gold = tgt_batch
+        for j in range(pred.size()[0]):
+            confusion[pred[j], gold[j]] += 1
+        correct += torch.sum(pred == gold).item()
+
+    args.logger.debug("Confusion matrix:")
+    args.logger.debug(confusion)
+    args.logger.debug("Report precision, recall, and f1:")
+
+    eps = 1e-9
+    for i in range(confusion.size()[0]):
+        p = confusion[i, i].item() / (confusion[i, :].sum().item() + eps)
+        r = confusion[i, i].item() / (confusion[:, i].sum().item() + eps)
+        f1 = 2 * p * r / (p + r + eps)
+        args.logger.debug("Label {}: {:.3f}, {:.3f}, {:.3f}".format(i, p, r, f1))
+
+    args.logger.info("Acc. (Correct/Total): {:.4f} ({}/{}) ".format(correct / len(dataset), correct, len(dataset)))
+    return correct / len(dataset), confusion
+
+
+def main():
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    finetune_opts(parser)
+
+    tokenizer_opts(parser)
+
+    args = parser.parse_args()
+
+    # Load the hyperparameters from the config file.
+    args = load_hyperparam(args)
+
+    set_seed(args.seed)
+
+    # Count the number of labels.
+    args.labels_num = count_labels_num(args.train_path)
+
+    # Build tokenizer.
+    args.tokenizer = str2tokenizer[args.tokenizer](args)
+
+    # Build classification model.
+    model = SiameseClassifier(args)
+
+    # Load or initialize parameters.
+    load_or_initialize_parameters(args, model)
+
+    # Get logger.
+    args.logger = init_logger(args)
+
+    args.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(args.device)
+
+    # Training phase.
+    trainset = read_dataset(args, args.train_path)
+    instances_num = len(trainset)
+    batch_size = args.batch_size
+
+    args.train_steps = int(instances_num * args.epochs_num / batch_size) + 1
+
+    args.logger.info("Batch size: {}".format(batch_size))
+    args.logger.info("The number of training instances: {}".format(instances_num))
+
+    optimizer, scheduler = build_optimizer(args, model)
+
+    if args.fp16:
+        try:
+            from apex import amp
+        except ImportError:
+            raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
+        model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level)
+        args.amp = amp
+
+    if torch.cuda.device_count() > 1:
+        args.logger.info("{} GPUs are available. Let's use them.".format(torch.cuda.device_count()))
+        model = torch.nn.DataParallel(model)
+    args.model = model
+
+    total_loss, result, best_result = 0.0, 0.0, 0.0
+
+    args.logger.info("Start training.")
+
+    for epoch in range(1, args.epochs_num + 1):
+        random.shuffle(trainset)
+        src_a = torch.LongTensor([example[0][0] for example in trainset])
+        src_b = torch.LongTensor([example[0][1] for example in trainset])
+        tgt = torch.LongTensor([example[1] for example in trainset])
+        seg_a = torch.LongTensor([example[2][0] for example in trainset])
+        seg_b = torch.LongTensor([example[2][1] for example in trainset])
+
+        model.train()
+        for i, (src_batch, tgt_batch, seg_batch) in enumerate(batch_loader(batch_size, (src_a, src_b), tgt, (seg_a, seg_b))):
+            loss = train_model(args, model, optimizer, scheduler, src_batch, tgt_batch, seg_batch)
+            total_loss += loss.item()
+            if (i + 1) % args.report_steps == 0:
+                args.logger.info("Epoch id: {}, Training steps: {}, Avg loss: {:.3f}".format(epoch, i + 1, total_loss / args.report_steps))
+                total_loss = 0.0
+
+        result = evaluate(args, read_dataset(args, args.dev_path))
+        if result[0] > best_result:
+            best_result = result[0]
+            save_model(model, args.output_model_path)
+
+    # Evaluation phase.
+    if args.test_path is not None:
+        args.logger.info("Test set evaluation.")
+        if torch.cuda.device_count() > 1:
+            args.model.module.load_state_dict(torch.load(args.output_model_path))
+        else:
+            args.model.load_state_dict(torch.load(args.output_model_path))
+        evaluate(args, read_dataset(args, args.test_path))
+
+
+if __name__ == "__main__":
+    main()

train/finetune/run_cmrc.py

@@ -0,0 +1,447 @@
+"""
+This script provides an example to wrap TencentPretrain for Chinese machine reading comprehension.
+"""
+import sys
+import os
+import re
+import argparse
+import json
+import random
+import torch
+import torch.nn as nn
+
+tencentpretrain_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(tencentpretrain_dir)
+
+from tencentpretrain.embeddings import *
+from tencentpretrain.encoders import *
+from tencentpretrain.utils.constants import *
+from tencentpretrain.utils.tokenizers import *
+from tencentpretrain.utils.optimizers import *
+from tencentpretrain.utils.config import load_hyperparam
+from tencentpretrain.utils.seed import set_seed
+from tencentpretrain.utils.logging import init_logger
+from tencentpretrain.model_saver import save_model
+from tencentpretrain.opts import finetune_opts
+from finetune.run_classifier import build_optimizer, load_or_initialize_parameters
+
+
+class MachineReadingComprehension(nn.Module):
+    def __init__(self, args):
+        super(MachineReadingComprehension, self).__init__()
+        self.embedding = Embedding(args)
+        for embedding_name in args.embedding:
+            tmp_emb = str2embedding[embedding_name](args, len(args.tokenizer.vocab))
+            self.embedding.update(tmp_emb, embedding_name)
+        self.encoder = str2encoder[args.encoder](args)
+        self.output_layer = nn.Linear(args.hidden_size, 2)
+
+    def forward(self, src, seg, start_position, end_position):
+        # Embedding.
+        emb = self.embedding(src, seg)
+        # Encoder.
+        output = self.encoder(emb, seg)
+        # Target.
+        logits = self.output_layer(output)
+
+        start_logits, end_logits = logits.split(1, dim=-1)
+        start_logits, end_logits = start_logits.squeeze(-1), end_logits.squeeze(-1)
+        start_loss = nn.NLLLoss()(nn.LogSoftmax(dim=-1)(start_logits), start_position)
+        end_loss = nn.NLLLoss()(nn.LogSoftmax(dim=-1)(end_logits), end_position)
+        loss = (start_loss + end_loss) / 2
+
+        return loss, start_logits, end_logits
+
+
+def read_examples(path):
+    # Read squad-style examples.
+    examples = []
+    with open(path, mode="r", encoding="utf-8") as f:
+        for article in json.load(f)["data"]:
+            for para in article["paragraphs"]:
+                context = para["context"]
+                for qa in para["qas"]:
+                    question = qa["question"]
+                    question_id = qa["id"]
+                    answer_texts, start_positions, end_positions = [], [], []
+                    for answer in qa["answers"]:
+                        answer_texts.append(answer["text"])
+                        start_positions.append(answer["answer_start"])
+                        end_positions.append(answer["answer_start"] + len(answer["text"]) - 1)
+                    examples.append((context, question, question_id, start_positions, end_positions, answer_texts))
+    return examples
+
+
+def convert_examples_to_dataset(args, examples):
+    # Converts a list of examples into a dataset that can be directly given as input to a model.
+    dataset = []
+    print("The number of questions in the dataset:{}".format(len(examples)))
+    for i in range(len(examples)):
+        context = examples[i][0]
+        question = examples[i][1]
+        question_id = examples[i][2]
+        # Only consider the first answer.
+        start_position_absolute = examples[i][3][0]
+        end_position_absolute = examples[i][4][0]
+        answers = examples[i][5]
+        max_context_length = args.seq_length - len(question) - 3
+        # Divide the context into multiple spans.
+        doc_spans = []
+        start_offset = 0
+        while start_offset < len(context):
+            length = len(context) - start_offset
+            if length > max_context_length:
+                length = max_context_length
+            doc_spans.append((start_offset, length))
+            if start_offset + length == len(context):
+                break
+            start_offset += min(length, args.doc_stride)
+
+        for doc_span_index, doc_span in enumerate(doc_spans):
+            start_offset = doc_span[0]
+            span_context = context[start_offset : start_offset + doc_span[1]]
+            # Convert absolute position to relative position.
+            start_position = start_position_absolute - start_offset + len(question) + 2
+            end_position = end_position_absolute - start_offset + len(question) + 2
+
+            # If span does not contain the complete answer, we use it for data augmentation.
+            if start_position < len(question) + 2:
+                start_position = len(question) + 2
+            if end_position > doc_span[1] + len(question) + 1:
+                end_position = doc_span[1] + len(question) + 1
+            if start_position > doc_span[1] + len(question) + 1 or end_position < len(question) + 2:
+                start_position, end_position = 0, 0
+
+            src_a = args.tokenizer.convert_tokens_to_ids([CLS_TOKEN] + args.tokenizer.tokenize(question) + [SEP_TOKEN])
+            src_b = args.tokenizer.convert_tokens_to_ids(args.tokenizer.tokenize(span_context) + [SEP_TOKEN])
+            src = src_a + src_b
+            seg = [1] * len(src_a) + [2] * len(src_b)
+            PAD_ID = args.tokenizer.convert_tokens_to_ids([PAD_TOKEN])[0]
+            while len(src) < args.seq_length:
+                src.append(PAD_ID)
+                seg.append(0)
+
+            dataset.append((src, seg, start_position, end_position, answers, question_id, len(question), doc_span_index, start_offset))
+    return dataset
+
+
+def read_dataset(args, path):
+    examples = read_examples(path)
+    dataset = convert_examples_to_dataset(args, examples)
+    return dataset, examples
+
+
+def batch_loader(batch_size, src, seg, start_position, end_position):
+    instances_num = src.size()[0]
+    for i in range(instances_num // batch_size):
+        src_batch = src[i * batch_size : (i + 1) * batch_size, :]
+        seg_batch = seg[i * batch_size : (i + 1) * batch_size, :]
+        start_position_batch = start_position[i * batch_size : (i + 1) * batch_size]
+        end_position_batch = end_position[i * batch_size : (i + 1) * batch_size]
+        yield src_batch, seg_batch, start_position_batch, end_position_batch
+    if instances_num > instances_num // batch_size * batch_size:
+        src_batch = src[instances_num // batch_size * batch_size :, :]
+        seg_batch = seg[instances_num // batch_size * batch_size :, :]
+        start_position_batch = start_position[instances_num // batch_size * batch_size :]
+        end_position_batch = end_position[instances_num // batch_size * batch_size :]
+        yield src_batch, seg_batch, start_position_batch, end_position_batch
+
+
+def train(args, model, optimizer, scheduler, src_batch, seg_batch, start_position_batch, end_position_batch):
+    model.zero_grad()
+
+    src_batch = src_batch.to(args.device)
+    seg_batch = seg_batch.to(args.device)
+    start_position_batch = start_position_batch.to(args.device)
+    end_position_batch = end_position_batch.to(args.device)
+
+    loss, _, _ = model(src_batch, seg_batch, start_position_batch, end_position_batch)
+    if torch.cuda.device_count() > 1:
+        loss = torch.mean(loss)
+
+    if args.fp16:
+        with amp.scale_loss(loss, optimizer) as scaled_loss:
+            scaled_loss.backward()
+    else:
+        loss.backward()
+
+    optimizer.step()
+    scheduler.step()
+
+    return loss
+
+
+# Evaluation script from CMRC2018.
+# We modify the tokenizer.
+def mixed_segmentation(in_str, rm_punc=False):
+    #in_str = str(in_str).decode('utf-8').lower().strip()
+    n_str = str(in_str).lower().strip()
+    segs_out = []
+    temp_str = ""
+    sp_char = ['-',':','_','*','^','/','\\','~','`','+','=',
+               '，','。','：','？','！','“','”','；','’','《','》','……','·','、',
+               '「','」','（','）','－','～','『','』']
+    for char in in_str:
+        if rm_punc and char in sp_char:
+            continue
+        #if re.search(ur'[\u4e00-\u9fa5]', char) or char in sp_char:
+        if re.search(r'[\u4e00-\u9fa5]', char) or char in sp_char:
+            if temp_str != "":
+                #ss = nltk.word_tokenize(temp_str)
+                ss = list(temp_str)
+                segs_out.extend(ss)
+                temp_str = ""
+            segs_out.append(char)
+        else:
+            temp_str += char
+
+    if temp_str != "":
+        #ss = nltk.word_tokenize(temp_str)
+        ss = list(temp_str)
+        segs_out.extend(ss)
+
+    return segs_out
+
+
+def find_lcs(s1, s2):
+    m = [[0 for i in range(len(s2)+1)] for j in range(len(s1)+1)]
+    mmax = 0
+    p = 0
+    for i in range(len(s1)):
+        for j in range(len(s2)):
+            if s1[i] == s2[j]:
+                m[i+1][j+1] = m[i][j]+1
+                if m[i+1][j+1] > mmax:
+                    mmax=m[i+1][j+1]
+                    p=i+1
+    return s1[p-mmax:p], mmax
+
+
+def remove_punctuation(in_str):
+    #in_str = str(in_str).decode('utf-8').lower().strip()
+    in_str = str(in_str).lower().strip()
+    sp_char = ['-',':','_','*','^','/','\\','~','`','+','=',
+               '，','。','：','？','！','“','”','；','’','《','》','……','·','、',
+               '「','」','（','）','－','～','『','』']
+    out_segs = []
+    for char in in_str:
+        if char in sp_char:
+            continue
+        else:
+            out_segs.append(char)
+    return ''.join(out_segs)
+
+
+def calc_f1_score(answers, prediction):
+    f1_scores = []
+    for ans in answers:
+        ans_segs = mixed_segmentation(ans, rm_punc=True)
+        prediction_segs = mixed_segmentation(prediction, rm_punc=True)
+        lcs, lcs_len = find_lcs(ans_segs, prediction_segs)
+        if lcs_len == 0:
+            f1_scores.append(0)
+            continue
+        precision   = 1.0*lcs_len/len(prediction_segs)
+        recall      = 1.0*lcs_len/len(ans_segs)
+        f1          = (2*precision*recall)/(precision+recall)
+        f1_scores.append(f1)
+    return max(f1_scores)
+
+
+def calc_em_score(answers, prediction):
+    em = 0
+    for ans in answers:
+        ans_ = remove_punctuation(ans)
+        prediction_ = remove_punctuation(prediction)
+        if ans_ == prediction_:
+            em = 1
+            break
+    return em
+
+
+def get_answers(dataset, start_prob_all, end_prob_all):
+    previous_question_id = -1
+    pred_answers = []
+    # For each predicted answer, we store its span index, start position, end position, and score.
+    current_answer = (-1, -1, -1, -100.0)
+    for i in range(len(dataset)):
+        question_id = dataset[i][5]
+        question_length = dataset[i][6]
+        span_index = dataset[i][7]
+        start_offset = dataset[i][8]
+
+        start_scores, end_scores = start_prob_all[i], end_prob_all[i]
+
+        start_pred = torch.argmax(start_scores[question_length + 2 :], dim=0) + question_length + 2
+        end_pred = start_pred + torch.argmax(end_scores[start_pred:], dim=0)
+        score = start_scores[start_pred] + end_scores[end_pred]
+
+        start_pred_absolute = start_pred + start_offset - question_length - 2
+        end_pred_absolute = end_pred + start_offset - question_length - 2
+
+        if question_id == previous_question_id:
+            if score > current_answer[3]:
+                current_answer = (span_index, start_pred_absolute, end_pred_absolute, score)
+        else:
+            if i > 0:
+                pred_answers.append(current_answer)
+            previous_question_id = question_id
+            current_answer = (span_index, start_pred_absolute, end_pred_absolute, score)
+    pred_answers.append(current_answer)
+    return pred_answers
+
+
+# Evaluation function.
+def evaluate(args, dataset, examples):
+    src = torch.LongTensor([sample[0] for sample in dataset])
+    seg = torch.LongTensor([sample[1] for sample in dataset])
+    start_position = torch.LongTensor([sample[2] for sample in dataset])
+    end_position = torch.LongTensor([sample[3] for sample in dataset])
+
+    batch_size = args.batch_size
+    instances_num = src.size()[0]
+
+    args.model.eval()
+    start_prob_all, end_prob_all = [], []
+
+    for i, (src_batch, seg_batch, start_position_batch, end_position_batch) in enumerate(batch_loader(batch_size, src, seg, start_position, end_position)):
+        src_batch = src_batch.to(args.device)
+        seg_batch = seg_batch.to(args.device)
+        start_position_batch = start_position_batch.to(args.device)
+        end_position_batch = end_position_batch.to(args.device)
+
+        with torch.no_grad():
+            loss, start_logits, end_logits = args.model(src_batch, seg_batch, start_position_batch, end_position_batch)
+
+        start_prob = nn.Softmax(dim=1)(start_logits)
+        end_prob = nn.Softmax(dim=1)(end_logits)
+
+        for j in range(start_prob.size()[0]):
+            start_prob_all.append(start_prob[j])
+            end_prob_all.append(end_prob[j])
+
+    pred_answers = get_answers(dataset, start_prob_all, end_prob_all)
+
+    f1, em = 0, 0
+    total_count, skip_count = len(examples), 0
+    for i in range(len(examples)):
+        answers = examples[i][5]
+        start_pred_pos = pred_answers[i][1]
+        end_pred_pos = pred_answers[i][2]
+
+        if end_pred_pos <= start_pred_pos:
+            skip_count += 1
+            continue
+
+        prediction = examples[i][0][start_pred_pos: end_pred_pos + 1]
+
+        f1 += calc_f1_score(answers, prediction)
+        em += calc_em_score(answers, prediction)
+
+    f1_score = 100.0 * f1 / total_count
+    em_score = 100.0 * em / total_count
+    avg = (f1_score + em_score) * 0.5
+    args.logger.info("Avg: {:.4f},F1:{:.4f},EM:{:.4f},Total:{},Skip:{}".format(avg, f1_score, em_score, total_count, skip_count))
+    return avg
+
+
+def main():
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    finetune_opts(parser)
+
+    parser.add_argument("--vocab_path", default=None, type=str,
+                        help="Path of the vocabulary file.")
+    parser.add_argument("--spm_model_path", default=None, type=str,
+                        help="Path of the sentence piece model.")
+    parser.add_argument("--doc_stride", default=128, type=int,
+                        help="When splitting up a long document into chunks, how much stride to take between chunks.")
+
+    args = parser.parse_args()
+
+    # Load the hyperparameters from the config file.
+    args = load_hyperparam(args)
+
+    set_seed(args.seed)
+
+    # Build tokenizer.
+    args.tokenizer = CharTokenizer(args)
+
+    # Build machine reading comprehension model.
+    model = MachineReadingComprehension(args)
+
+    # Load or initialize parameters.
+    load_or_initialize_parameters(args, model)
+
+    # Get logger.
+    args.logger = init_logger(args)
+
+    args.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(args.device)
+
+    # Build tokenizer.
+    args.tokenizer = CharTokenizer(args)
+
+    # Training phase.
+    batch_size = args.batch_size
+    args.logger.info("Batch size: {}".format(batch_size))
+    trainset, _ = read_dataset(args, args.train_path)
+    instances_num = len(trainset)
+
+    args.train_steps = int(instances_num * args.epochs_num / batch_size) + 1
+
+    args.logger.info("The number of training instances: {}".format(instances_num))
+
+    optimizer, scheduler = build_optimizer(args, model)
+
+    if args.fp16:
+        try:
+            from apex import amp
+        except ImportError:
+            raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
+        model, optimizer = amp.initialize(model, optimizer,opt_level=args.fp16_opt_level)
+
+    if torch.cuda.device_count() > 1:
+        args.logger.info("{} GPUs are available. Let's use them.".format(torch.cuda.device_count()))
+        model = torch.nn.DataParallel(model)
+    args.model = model
+
+    total_loss = 0.0
+    result = 0.0
+    best_result = 0.0
+
+    args.logger.info("Start training.")
+
+    for epoch in range(1, args.epochs_num + 1):
+        random.shuffle(trainset)
+        src = torch.LongTensor([sample[0] for sample in trainset])
+        seg = torch.LongTensor([sample[1] for sample in trainset])
+        start_position = torch.LongTensor([sample[2] for sample in trainset])
+        end_position = torch.LongTensor([sample[3] for sample in trainset])
+
+        model.train()
+
+        for i, (src_batch, seg_batch, start_position_batch, end_position_batch) in enumerate(batch_loader(batch_size, src, seg, start_position, end_position)):
+            loss = train(args, model, optimizer, scheduler, src_batch, seg_batch, start_position_batch, end_position_batch)
+            total_loss += loss.item()
+            if (i + 1) % args.report_steps == 0:
+                args.logger.info("Epoch id: {}, Training steps: {}, Avg loss: {:.3f}".format(epoch, i+1, total_loss / args.report_steps))
+                total_loss = 0.0
+
+        result = evaluate(args, *read_dataset(args, args.dev_path))
+        if result > best_result:
+            best_result = result
+            save_model(model, args.output_model_path)
+
+    # Evaluation phase.
+    if args.test_path is not None:
+        args.logger.info("Test set evaluation.")
+        if torch.cuda.device_count() > 1:
+            args.model.module.load_state_dict(torch.load(args.output_model_path))
+        else:
+            args.model.load_state_dict(torch.load(args.output_model_path))
+        evaluate(args, *read_dataset(args, args.test_path))
+
+
+if __name__ == "__main__":
+    main()

train/finetune/run_dbqa.py

@@ -0,0 +1,232 @@
+"""
+This script provides an exmaple to wrap TencentPretrain for document-based question answering.
+"""
+import sys
+import os
+import random
+import argparse
+import torch
+
+tencentpretrain_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(tencentpretrain_dir)
+
+from tencentpretrain.utils.constants import *
+from tencentpretrain.utils import *
+from tencentpretrain.utils.optimizers import *
+from tencentpretrain.utils.config import load_hyperparam
+from tencentpretrain.utils.seed import set_seed
+from tencentpretrain.utils.logging import init_logger
+from tencentpretrain.model_saver import save_model
+from tencentpretrain.opts import finetune_opts, tokenizer_opts, adv_opts
+from finetune.run_classifier import Classifier, count_labels_num, build_optimizer, batch_loader, train_model, load_or_initialize_parameters
+
+
+def read_dataset(args, path):
+    dataset, columns = [], {}
+    with open(path, mode="r", encoding="utf-8") as f:
+        for line_id, line in enumerate(f):
+            if line_id == 0:
+                for i, column_name in enumerate(line.rstrip("\r\n").split("\t")):
+                    columns[column_name] = i
+                continue
+            line = line.rstrip("\r\n").split("\t")
+            qid = int(line[columns["qid"]])
+            tgt = int(line[columns["label"]])
+            text_a, text_b = line[columns["text_a"]], line[columns["text_b"]]
+            src_a = args.tokenizer.convert_tokens_to_ids([CLS_TOKEN] + args.tokenizer.tokenize(text_a) + [SEP_TOKEN])
+            src_b = args.tokenizer.convert_tokens_to_ids(args.tokenizer.tokenize(text_b) + [SEP_TOKEN])
+            src = src_a + src_b
+            seg = [1] * len(src_a) + [2] * len(src_b)
+
+            if len(src) > args.seq_length:
+                src = src[: args.seq_length]
+                seg = seg[: args.seq_length]
+            PAD_ID = args.tokenizer.convert_tokens_to_ids([PAD_TOKEN])[0]
+            while len(src) < args.seq_length:
+                src.append(PAD_ID)
+                seg.append(0)
+            dataset.append((src, tgt, seg, qid))
+
+    return dataset
+
+
+def gen_dataset_groupby_qid(dataset, logits_all):
+    dataset_groupby_qid, correct_answer_orders, scores = [], [], []
+    for i in range(len(dataset)):
+        label = dataset[i][1]
+        if i == 0:
+            qid = dataset[i][3]
+            # Order of the current sentence in the document.
+            current_order = 0
+            scores.append(float(logits_all[i][1].item()))
+            if label == 1:
+                # Occasionally, more than one sentences in a document contain answers.
+                correct_answer_orders.append(current_order)
+            current_order += 1
+            continue
+        if qid == dataset[i][3]:
+            scores.append(float(logits_all[i][1].item()))
+            if label == 1:
+                correct_answer_orders.append(current_order)
+            current_order += 1
+        else:
+            # For each question, we record which sentences contain answers
+            # and the scores of all sentences in the document.
+            dataset_groupby_qid.append((qid, correct_answer_orders, scores))
+            correct_answer_orders, scores, current_order = [], [], 0
+            qid = dataset[i][3]
+            scores.append(float(logits_all[i][1].item()))
+            if label == 1:
+                correct_answer_orders.append(current_order)
+            current_order += 1
+    dataset_groupby_qid.append((qid, correct_answer_orders, scores))
+    return dataset_groupby_qid
+
+
+def evaluate(args, dataset):
+    src = torch.LongTensor([sample[0] for sample in dataset])
+    tgt = torch.LongTensor([sample[1] for sample in dataset])
+    seg = torch.LongTensor([sample[2] for sample in dataset])
+
+    batch_size = args.batch_size
+    instances_num = src.size()[0]
+
+    args.model.eval()
+
+    for i, (src_batch, tgt_batch, seg_batch, _) in enumerate(batch_loader(batch_size, src, tgt, seg)):
+        src_batch = src_batch.to(args.device)
+        tgt_batch = tgt_batch.to(args.device)
+        seg_batch = seg_batch.to(args.device)
+        with torch.no_grad():
+            loss, logits = args.model(src_batch, tgt_batch, seg_batch)
+        if i == 0:
+            logits_all = logits
+        if i >= 1:
+            logits_all = torch.cat((logits_all, logits), 0)
+
+    # To calculate MRR, the results are grouped by qid.
+    dataset_groupby_qid = gen_dataset_groupby_qid(dataset, logits_all)
+
+    reciprocal_rank = []
+    for _, correct_answer_orders, scores in dataset_groupby_qid:
+        if len(correct_answer_orders) == 1:
+            sorted_scores = sorted(scores, reverse=True)
+            for j in range(len(sorted_scores)):
+                if sorted_scores[j] == scores[correct_answer_orders[0]]:
+                    reciprocal_rank.append(1 / (j + 1))
+        else:
+            current_rank = len(scores)
+            sorted_scores = sorted(scores, reverse=True)
+            for i in range(len(correct_answer_orders)):
+                for j in range(len(scores)):
+                    if sorted_scores[j] == scores[correct_answer_orders[i]] and j < current_rank:
+                        current_rank = j
+            reciprocal_rank.append(1 / (current_rank + 1))
+
+    MRR = sum(reciprocal_rank) / len(reciprocal_rank)
+    args.logger.info("Mean Reciprocal Rank: {:.4f}".format(MRR))
+    return MRR
+
+
+def main():
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    finetune_opts(parser)
+
+    tokenizer_opts(parser)
+
+    parser.add_argument("--soft_targets", action='store_true',
+                        help="Train model with logits.")
+    parser.add_argument("--soft_alpha", type=float, default=0.5,
+                        help="Weight of the soft targets loss.")
+
+    adv_opts(parser)
+
+    args = parser.parse_args()
+
+    # Load the hyperparameters from the config file.
+    args = load_hyperparam(args)
+
+    set_seed(args.seed)
+
+    # Count the number of labels.
+    args.labels_num = count_labels_num(args.train_path)
+
+    # Build tokenizer.
+    args.tokenizer = str2tokenizer[args.tokenizer](args)
+
+    # Build classification model.
+    model = Classifier(args)
+
+    # Load or initialize parameters.
+    load_or_initialize_parameters(args, model)
+
+    # Get logger.
+    args.logger = init_logger(args)
+
+    args.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(args.device)
+
+    # Training phase.
+    trainset = read_dataset(args, args.train_path)
+    instances_num = len(trainset)
+    batch_size = args.batch_size
+
+    args.train_steps = int(instances_num * args.epochs_num / batch_size) + 1
+
+    args.logger.info("Batch size: {}".format(batch_size))
+    args.logger.info("The number of training instances: {}".format(instances_num))
+
+    optimizer, scheduler = build_optimizer(args, model)
+
+    if args.fp16:
+        try:
+            from apex import amp
+        except ImportError:
+            raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
+        model, optimizer = amp.initialize(model, optimizer,opt_level = args.fp16_opt_level)
+        args.amp = amp
+
+    if torch.cuda.device_count() > 1:
+        args.logger.info("{} GPUs are available. Let's use them.".format(torch.cuda.device_count()))
+        model = torch.nn.DataParallel(model)
+    args.model = model
+
+    if args.use_adv:
+        args.adv_method = str2adv[args.adv_type](model)
+
+    total_loss, result, best_result = 0.0, 0.0, 0.0
+
+    args.logger.info("Start training.")
+
+    for epoch in range(1, args.epochs_num + 1):
+        random.shuffle(trainset)
+        src = torch.LongTensor([example[0] for example in trainset])
+        tgt = torch.LongTensor([example[1] for example in trainset])
+        seg = torch.LongTensor([example[2] for example in trainset])
+
+        model.train()
+        for i, (src_batch, tgt_batch, seg_batch, _) in enumerate(batch_loader(batch_size, src, tgt, seg)):
+            loss = train_model(args, model, optimizer, scheduler, src_batch, tgt_batch, seg_batch)
+            total_loss += loss.item()
+            if (i + 1) % args.report_steps == 0:
+                args.logger.info("Epoch id: {}, Training steps: {}, Avg loss: {:.3f}".format(epoch, i + 1, total_loss / args.report_steps))
+                total_loss = 0.0
+
+        result = evaluate(args, read_dataset(args, args.dev_path))
+        if result > best_result:
+            best_result = result
+            save_model(model, args.output_model_path)
+
+    # Evaluation phase.
+    if args.test_path is not None:
+        args.logger.info("Test set evaluation.")
+        if torch.cuda.device_count() > 1:
+            args.model.module.load_state_dict(torch.load(args.output_model_path))
+        else:
+            args.model.load_state_dict(torch.load(args.output_model_path))
+        evaluate(args, read_dataset(args, args.test_path))
+
+
+if __name__ == "__main__":
+    main()

train/finetune/run_image_classifier.py

@@ -0,0 +1,195 @@
+"""
+This script provides an exmaple to wrap TencentPretrain for image classification.
+"""
+import sys
+import os
+import random
+import argparse
+import torch
+import torch.nn as nn
+import torchvision.datasets as dest
+from torchvision import transforms
+from torchvision.io import read_image
+from torchvision.io.image import ImageReadMode
+
+tencentpretrain_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(tencentpretrain_dir)
+
+from tencentpretrain.layers import *
+from tencentpretrain.encoders import *
+from tencentpretrain.utils.vocab import Vocab
+from tencentpretrain.utils.constants import *
+from tencentpretrain.utils import *
+from tencentpretrain.utils.optimizers import *
+from tencentpretrain.utils.config import load_hyperparam
+from tencentpretrain.utils.misc import ZeroOneNormalize, count_lines
+from tencentpretrain.utils.seed import set_seed
+from tencentpretrain.model_saver import save_model
+from tencentpretrain.opts import finetune_opts
+from finetune.run_classifier import *
+
+
+def data_loader(args, path):
+
+    transform = transforms.Compose([
+        transforms.Resize((args.image_height, args.image_width)),
+        ZeroOneNormalize()
+    ])
+
+    dataset, columns = [], {}
+    with open(path, mode="r", encoding="utf-8") as f:
+        src_batch, tgt_batch, seg_batch = [], [], []
+        for line_id, line in enumerate(f):
+            if line_id == 0:
+                for i, column_name in enumerate(line.rstrip("\r\n").split("\t")):
+                    columns[column_name] = i
+                continue
+            line = line.rstrip("\r\n").split("\t")
+            tgt = int(line[columns["label"]])
+            path = line[columns["path"]]
+            image = read_image(path, ImageReadMode.RGB)
+            image = image.to(args.device)
+            src = transform(image)
+            seg = [1] * ((src.size()[1] // args.patch_size) * (src.size()[2] // args.patch_size) + 1)
+
+            src_batch.append(src)
+            tgt_batch.append(tgt)
+            seg_batch.append(seg)
+
+            if len(src_batch) == args.batch_size:
+                yield torch.stack(src_batch, 0), \
+                      torch.LongTensor(tgt_batch), \
+                      torch.LongTensor(seg_batch)
+                src_batch, tgt_batch, seg_batch = [], [], []
+
+        if len(src_batch) > 0:
+            yield torch.stack(src_batch, 0), \
+                  torch.LongTensor(tgt_batch), \
+                  torch.LongTensor(seg_batch)
+
+
+def evaluate(args, dataset_path):
+
+    correct, instances_num = 0, 0
+    # Confusion matrix.
+    confusion = torch.zeros(args.labels_num, args.labels_num, dtype=torch.long)
+
+    args.model.eval()
+
+    for i, (src_batch, tgt_batch, seg_batch) in enumerate(data_loader(args, dataset_path)):
+        src_batch = src_batch.to(args.device)
+        tgt_batch = tgt_batch.to(args.device)
+        seg_batch = seg_batch.to(args.device)
+        with torch.no_grad():
+            _, logits = args.model(src_batch, tgt_batch, seg_batch)
+        pred = torch.argmax(nn.Softmax(dim=1)(logits), dim=1)
+        gold = tgt_batch
+        for j in range(pred.size()[0]):
+            confusion[pred[j], gold[j]] += 1
+        correct += torch.sum(pred == gold).item()
+        instances_num += len(pred)
+
+    args.logger.info("Confusion matrix:")
+    args.logger.info(confusion)
+    args.logger.info("Report precision, recall, and f1:")
+
+    eps = 1e-9
+    for i in range(confusion.size()[0]):
+        p = confusion[i, i].item() / (confusion[i, :].sum().item() + eps)
+        r = confusion[i, i].item() / (confusion[:, i].sum().item() + eps)
+        f1 = 2 * p * r / (p + r + eps)
+        args.logger.info("Label {}: {:.3f}, {:.3f}, {:.3f}".format(i, p, r, f1))
+
+    args.logger.info("Acc. (Correct/Total): {:.4f} ({}/{}) ".format(correct / instances_num, correct, instances_num))
+    return correct / instances_num, confusion
+
+
+def main():
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    finetune_opts(parser)
+
+    tokenizer_opts(parser)
+
+    adv_opts(parser)
+
+    args = parser.parse_args()
+
+    # Load the hyperparameters from the config file.
+    args = load_hyperparam(args)
+    args.soft_targets, args.soft_alpha = False, 0
+
+    # Count the number of labels.
+    args.labels_num = count_labels_num(args.train_path)
+    instances_num = count_lines(args.train_path) - 1
+
+
+    # Build tokenizer.
+    args.tokenizer = str2tokenizer["virtual"](args)
+    set_seed(args.seed)
+
+    # Build classification model.
+    model = Classifier(args)
+
+    # Load or initialize parameters.
+    load_or_initialize_parameters(args, model)
+
+    # Get logger.
+    args.logger = init_logger(args)
+
+    args.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(args.device)
+
+    # Training phase.
+    batch_size = args.batch_size
+
+    args.train_steps = int(instances_num * args.epochs_num / batch_size) + 1
+
+    args.logger.info("Batch size: {}".format(batch_size))
+    args.logger.info("The number of training instances: {}".format(instances_num))
+    optimizer, scheduler = build_optimizer(args, model)
+
+    if args.fp16:
+        try:
+            from apex import amp
+        except ImportError:
+            raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
+        model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level)
+        args.amp = amp
+
+    if torch.cuda.device_count() > 1:
+        args.logger.info("{} GPUs are available. Let's use them.".format(torch.cuda.device_count()))
+        model = torch.nn.DataParallel(model)
+    args.model = model
+
+    if args.use_adv:
+        args.adv_method = str2adv[args.adv_type](model)
+
+    total_loss, result, best_result = 0.0, 0.0, 0.0
+
+    args.logger.info("Start training.")
+    for epoch in range(1, args.epochs_num + 1):
+        model.train()
+        for i, (src_batch, tgt_batch, seg_batch) in enumerate(data_loader(args, args.train_path)):
+            loss = train_model(args, model, optimizer, scheduler, src_batch, tgt_batch, seg_batch)
+            total_loss += loss.item()
+            if (i + 1) % args.report_steps == 0:
+                args.logger.info("Epoch id: {}, Training steps: {}, Avg loss: {:.3f}".format(epoch, i + 1, total_loss / args.report_steps))
+                total_loss = 0.0
+
+        result = evaluate(args, args.dev_path)
+        if result[0] > best_result:
+            best_result = result[0]
+            save_model(model, args.output_model_path)
+
+    # Evaluation phase.
+    if args.test_path is not None:
+        args.logger.info("Test set evaluation.")
+        if torch.cuda.device_count() > 1:
+            args.model.module.load_state_dict(torch.load(args.output_model_path))
+        else:
+            args.model.load_state_dict(torch.load(args.output_model_path))
+        evaluate(args, args.test_path)
+
+if __name__ == "__main__":
+    main()

train/finetune/run_ner.py

@@ -0,0 +1,339 @@
+"""
+  This script provides an example to wrap TencentPretrain for NER.
+"""
+import sys
+import os
+import random
+import argparse
+import json
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+tencentpretrain_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(tencentpretrain_dir)
+
+from tencentpretrain.embeddings import *
+from tencentpretrain.encoders import *
+from tencentpretrain.utils.config import load_hyperparam
+from tencentpretrain.utils.optimizers import *
+from tencentpretrain.utils.constants import *
+from tencentpretrain.utils.vocab import Vocab
+from tencentpretrain.utils.seed import set_seed
+from tencentpretrain.utils.logging import init_logger
+from tencentpretrain.utils.tokenizers import *
+from tencentpretrain.model_saver import save_model
+from tencentpretrain.opts import finetune_opts
+from finetune.run_classifier import build_optimizer, load_or_initialize_parameters
+
+
+class NerTagger(nn.Module):
+    def __init__(self, args):
+        super(NerTagger, self).__init__()
+        self.embedding = Embedding(args)
+        for embedding_name in args.embedding:
+            tmp_emb = str2embedding[embedding_name](args, len(args.tokenizer.vocab))
+            self.embedding.update(tmp_emb, embedding_name)
+        self.encoder = str2encoder[args.encoder](args)
+        self.labels_num = args.labels_num
+        self.output_layer = nn.Linear(args.hidden_size, self.labels_num)
+        self.crf_target = args.crf_target
+        if args.crf_target:
+            from torchcrf import CRF
+            self.crf = CRF(self.labels_num, batch_first=True)
+            self.seq_length = args.seq_length
+
+    def forward(self, src, tgt, seg):
+        """
+        Args:
+            src: [batch_size x seq_length]
+            tgt: [batch_size x seq_length]
+            seg: [batch_size x seq_length]
+        Returns:
+            loss: Sequence labeling loss.
+            logits: Output logits.
+        """
+        # Embedding.
+        emb = self.embedding(src, seg)
+        # Encoder.
+        output = self.encoder(emb, seg)
+
+        # Target.
+        logits = self.output_layer(output)
+        if self.crf_target:
+            tgt_mask = seg.type(torch.uint8)
+            pred = self.crf.decode(logits, mask=tgt_mask)
+            for j in range(len(pred)):
+                while len(pred[j]) < self.seq_length:
+                    pred[j].append(self.labels_num - 1)
+            pred = torch.tensor(pred).contiguous().view(-1)
+            if tgt is not None:
+                loss = -self.crf(F.log_softmax(logits, 2), tgt, mask=tgt_mask, reduction='mean')
+                return loss, pred
+            else:
+                return None, pred
+        else:
+            tgt_mask = seg.contiguous().view(-1).float()
+            logits = logits.contiguous().view(-1, self.labels_num)
+            pred = logits.argmax(dim=-1)
+            if tgt is not None:
+                tgt = tgt.contiguous().view(-1, 1)
+                one_hot = torch.zeros(tgt.size(0), self.labels_num). \
+                    to(torch.device(tgt.device)). \
+                    scatter_(1, tgt, 1.0)
+                numerator = -torch.sum(nn.LogSoftmax(dim=-1)(logits) * one_hot, 1)
+                numerator = torch.sum(tgt_mask * numerator)
+                denominator = torch.sum(tgt_mask) + 1e-6
+                loss = numerator / denominator
+                return loss, pred
+            else:
+                return None, pred
+
+
+def read_dataset(args, path):
+    dataset, columns = [], {}
+    with open(path, mode="r", encoding="utf-8") as f:
+        for line_id, line in enumerate(f):
+            if line_id == 0:
+                for i, column_name in enumerate(line.rstrip("\r\n").split("\t")):
+                    columns[column_name] = i
+                continue
+            line = line.rstrip("\r\n").split("\t")
+            labels = line[columns["label"]]
+            tgt = [args.l2i[l] for l in labels.split(" ")]
+
+            text_a = line[columns["text_a"]]
+            src = args.tokenizer.convert_tokens_to_ids(args.tokenizer.tokenize(text_a))
+            seg = [1] * len(src)
+
+            if len(src) > args.seq_length:
+                src = src[: args.seq_length]
+                tgt = tgt[: args.seq_length]
+                seg = seg[: args.seq_length]
+            PAD_ID = args.tokenizer.convert_tokens_to_ids([PAD_TOKEN])[0]
+            while len(src) < args.seq_length:
+                src.append(PAD_ID)
+                tgt.append(args.labels_num - 1)
+                seg.append(0)
+            dataset.append([src, tgt, seg])
+
+    return dataset
+
+
+def batch_loader(batch_size, src, tgt, seg):
+    instances_num = src.size()[0]
+    for i in range(instances_num // batch_size):
+        src_batch = src[i * batch_size : (i + 1) * batch_size, :]
+        tgt_batch = tgt[i * batch_size : (i + 1) * batch_size, :]
+        seg_batch = seg[i * batch_size : (i + 1) * batch_size, :]
+        yield src_batch, tgt_batch, seg_batch
+    if instances_num > instances_num // batch_size * batch_size:
+        src_batch = src[instances_num // batch_size * batch_size :, :]
+        tgt_batch = tgt[instances_num // batch_size * batch_size :, :]
+        seg_batch = seg[instances_num // batch_size * batch_size :, :]
+        yield src_batch, tgt_batch, seg_batch
+
+
+def train(args, model, optimizer, scheduler, src_batch, tgt_batch, seg_batch):
+    model.zero_grad()
+
+    src_batch = src_batch.to(args.device)
+    tgt_batch = tgt_batch.to(args.device)
+    seg_batch = seg_batch.to(args.device)
+
+    loss, _ = model(src_batch, tgt_batch, seg_batch)
+    if torch.cuda.device_count() > 1:
+        loss = torch.mean(loss)
+
+    if args.fp16:
+        with amp.scale_loss(loss, optimizer) as scaled_loss:
+            scaled_loss.backward()
+    else:
+        loss.backward()
+
+    optimizer.step()
+    scheduler.step()
+
+    return loss
+
+
+def evaluate(args, dataset):
+    src = torch.LongTensor([sample[0] for sample in dataset])
+    tgt = torch.LongTensor([sample[1] for sample in dataset])
+    seg = torch.LongTensor([sample[2] for sample in dataset])
+
+    instances_num = src.size(0)
+    batch_size = args.batch_size
+
+    correct, gold_entities_num, pred_entities_num = 0, 0, 0
+
+    args.model.eval()
+
+    for i, (src_batch, tgt_batch, seg_batch) in enumerate(batch_loader(batch_size, src, tgt, seg)):
+        src_batch = src_batch.to(args.device)
+        tgt_batch = tgt_batch.to(args.device)
+        seg_batch = seg_batch.to(args.device)
+        loss, pred = args.model(src_batch, tgt_batch, seg_batch)
+
+        gold = tgt_batch.contiguous().view(-1, 1)
+
+        for j in range(gold.size()[0]):
+            if gold[j].item() in args.begin_ids:
+                gold_entities_num += 1
+
+        for j in range(pred.size()[0]):
+            if pred[j].item() in args.begin_ids and gold[j].item() != args.l2i["[PAD]"]:
+                pred_entities_num += 1
+
+        pred_entities_pos, gold_entities_pos = set(), set()
+
+        for j in range(gold.size()[0]):
+            if gold[j].item() in args.begin_ids:
+                start = j
+                for k in range(j + 1, gold.size()[0]):
+                    if gold[k].item() == args.l2i["[PAD]"] or gold[k].item() == args.l2i["O"] or gold[k].item() in args.begin_ids:
+                        end = k - 1
+                        break
+                else:
+                    end = gold.size()[0] - 1
+                gold_entities_pos.add((start, end))
+
+        for j in range(pred.size()[0]):
+            if pred[j].item() in args.begin_ids and gold[j].item() != args.l2i["[PAD]"]:
+                start = j
+                for k in range(j + 1, pred.size()[0]):
+                    if pred[k].item() == args.l2i["[PAD]"] or pred[k].item() == args.l2i["O"] or pred[k].item() in args.begin_ids:
+                        end = k - 1
+                        break
+                else:
+                    end = pred.size()[0] - 1
+                pred_entities_pos.add((start, end))
+
+        for entity in pred_entities_pos:
+            if entity not in gold_entities_pos:
+                continue
+            for j in range(entity[0], entity[1] + 1):
+                if gold[j].item() != pred[j].item():
+                    break
+            else:
+                correct += 1
+
+    args.logger.info("Report precision, recall, and f1:")
+    eps = 1e-9
+    p = correct / (pred_entities_num + eps)
+    r = correct / (gold_entities_num + eps)
+    f1 = 2 * p * r / (p + r + eps)
+    args.logger.info("{:.3f}, {:.3f}, {:.3f}".format(p, r, f1))
+
+    return f1
+
+
+def main():
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    finetune_opts(parser)
+
+    parser.add_argument("--vocab_path", default=None, type=str,
+                        help="Path of the vocabulary file.")
+    parser.add_argument("--spm_model_path", default=None, type=str,
+                        help="Path of the sentence piece model.")
+    parser.add_argument("--label2id_path", type=str, required=True,
+                        help="Path of the label2id file.")
+    parser.add_argument("--crf_target", action="store_true",
+                        help="Use CRF loss as the target function or not, default False.")
+
+    args = parser.parse_args()
+
+    # Load the hyperparameters of the config file.
+    args = load_hyperparam(args)
+
+    # Get logger.
+    args.logger = init_logger(args)
+
+    set_seed(args.seed)
+
+    args.begin_ids = []
+
+    with open(args.label2id_path, mode="r", encoding="utf-8") as f:
+        l2i = json.load(f)
+        args.logger.info("Labels: " + str(l2i))
+        l2i["[PAD]"] = len(l2i)
+        for label in l2i:
+            if label.startswith("B"):
+                args.begin_ids.append(l2i[label])
+
+    args.l2i = l2i
+
+    args.labels_num = len(l2i)
+
+    args.tokenizer = SpaceTokenizer(args)
+
+    # Build sequence labeling model.
+    model = NerTagger(args)
+
+    # Load or initialize parameters.
+    load_or_initialize_parameters(args, model)
+
+    args.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(args.device)
+
+    # Training phase.
+    instances = read_dataset(args, args.train_path)
+    instances_num = len(instances)
+    batch_size = args.batch_size
+    args.train_steps = int(instances_num * args.epochs_num / batch_size) + 1
+
+    args.logger.info("Batch size: {}".format(batch_size))
+    args.logger.info("The number of training instances: {}".format(instances_num))
+
+    optimizer, scheduler = build_optimizer(args, model)
+
+    if args.fp16:
+        try:
+            from apex import amp
+        except ImportError:
+            raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
+        model, optimizer = amp.initialize(model, optimizer, opt_level = args.fp16_opt_level)
+
+    if torch.cuda.device_count() > 1:
+        args.logger.info("{} GPUs are available. Let's use them.".format(torch.cuda.device_count()))
+        model = torch.nn.DataParallel(model)
+    args.model = model
+
+    total_loss, f1, best_f1 = 0.0, 0.0, 0.0
+
+    args.logger.info("Start training.")
+
+    for epoch in range(1, args.epochs_num + 1):
+        random.shuffle(instances)
+        src = torch.LongTensor([ins[0] for ins in instances])
+        tgt = torch.LongTensor([ins[1] for ins in instances])
+        seg = torch.LongTensor([ins[2] for ins in instances])
+
+        model.train()
+        for i, (src_batch, tgt_batch, seg_batch) in enumerate(batch_loader(batch_size, src, tgt, seg)):
+            loss = train(args, model, optimizer, scheduler, src_batch, tgt_batch, seg_batch)
+            total_loss += loss.item()
+            if (i + 1) % args.report_steps == 0:
+                args.logger.info("Epoch id: {}, Training steps: {}, Avg loss: {:.3f}".format(epoch, i + 1, total_loss / args.report_steps))
+                total_loss = 0.0
+
+        f1 = evaluate(args, read_dataset(args, args.dev_path))
+        if f1 > best_f1:
+            best_f1 = f1
+            save_model(model, args.output_model_path)
+        else:
+            continue
+
+    # Evaluation phase.
+    if args.test_path is not None:
+        args.logger.info("Test set evaluation.")
+        if torch.cuda.device_count() > 1:
+            args.model.module.load_state_dict(torch.load(args.output_model_path))
+        else:
+            args.model.load_state_dict(torch.load(args.output_model_path))
+        evaluate(args, read_dataset(args, args.test_path))
+
+
+if __name__ == "__main__":
+    main()

train/finetune/run_regression.py

@@ -0,0 +1,199 @@
+"""
+This script provides an example to wrap TencentPretrain for regression.
+"""
+import sys
+import os
+import random
+import argparse
+import torch
+import torch.nn as nn
+
+tencentpretrain_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(tencentpretrain_dir)
+
+from finetune.run_classifier import *
+from scipy.stats import spearmanr
+
+
+class Regression(nn.Module):
+    def __init__(self, args):
+        super(Regression, self).__init__()
+        self.embedding = Embedding(args)
+        for embedding_name in args.embedding:
+            tmp_emb = str2embedding[embedding_name](args, len(args.tokenizer.vocab))
+            self.embedding.update(tmp_emb, embedding_name)
+        self.encoder = str2encoder[args.encoder](args)
+        self.pooling_type = args.pooling
+        self.output_layer_1 = nn.Linear(args.hidden_size, args.hidden_size)
+        self.output_layer_2 = nn.Linear(args.hidden_size, 1)
+
+    def forward(self, src, tgt, seg, soft_tgt=None):
+        """
+        Args:
+            src: [batch_size x seq_length]
+            tgt: [batch_size]
+            seg: [batch_size x seq_length]
+        """
+        # Embedding.
+        emb = self.embedding(src, seg)
+        # Encoder.
+        output = self.encoder(emb, seg)
+        # Target.
+        output = pooling(output, seg, self.pooling_type)
+        output = torch.tanh(self.output_layer_1(output))
+        logits = self.output_layer_2(output)
+        if tgt is not None:
+            loss = nn.MSELoss()(logits.view(-1), tgt.view(-1))
+            return loss, logits
+        else:
+            return None, logits
+
+
+def read_dataset(args, path):
+    dataset, columns = [], {}
+    with open(path, mode="r", encoding="utf-8") as f:
+        for line_id, line in enumerate(f):
+            if line_id == 0:
+                for i, column_name in enumerate(line.rstrip("\r\n").split("\t")):
+                    columns[column_name] = i
+                continue
+            line = line.rstrip("\r\n").split("\t")
+            tgt = float(line[columns["label"]])
+            if "text_b" not in columns:
+                text_a = line[columns["text_a"]]
+                src = args.tokenizer.convert_tokens_to_ids([CLS_TOKEN] + args.tokenizer.tokenize(text_a) + [SEP_TOKEN])
+                seg = [1] * len(src)
+            else:
+                text_a, text_b = line[columns["text_a"]], line[columns["text_b"]]
+                src_a = args.tokenizer.convert_tokens_to_ids([CLS_TOKEN] + args.tokenizer.tokenize(text_a) + [SEP_TOKEN])
+                src_b = args.tokenizer.convert_tokens_to_ids(args.tokenizer.tokenize(text_b) + [SEP_TOKEN])
+                src = src_a + src_b
+                seg = [1] * len(src_a) + [2] * len(src_b)
+
+            if len(src) > args.seq_length:
+                src = src[: args.seq_length]
+                seg = seg[: args.seq_length]
+            PAD_ID = args.tokenizer.convert_tokens_to_ids([PAD_TOKEN])[0]
+            while len(src) < args.seq_length:
+                src.append(PAD_ID)
+                seg.append(0)
+            dataset.append((src, tgt, seg))
+
+    return dataset
+
+
+def evaluate(args, dataset):
+    src = torch.LongTensor([sample[0] for sample in dataset])
+    tgt = torch.FloatTensor([sample[1] for sample in dataset])
+    seg = torch.LongTensor([sample[2] for sample in dataset])
+    pred_list = []
+    gold_list = []
+    batch_size = args.batch_size
+
+    args.model.eval()
+
+    for i, (src_batch, tgt_batch, seg_batch, _) in enumerate(batch_loader(batch_size, src, tgt, seg)):
+        src_batch = src_batch.to(args.device)
+        tgt_batch = tgt_batch.to(args.device)
+        seg_batch = seg_batch.to(args.device)
+        with torch.no_grad():
+            _, pred = args.model(src_batch, tgt_batch, seg_batch)
+        gold = tgt_batch
+        pred_list += pred.tolist()
+        gold_list += gold.tolist()
+    spearman_corr, _ = spearmanr(gold_list, pred_list)
+
+    args.logger.info("Spearman corr: {:.4f}".format(spearman_corr))
+    return spearman_corr
+
+
+def main():
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    finetune_opts(parser)
+
+    tokenizer_opts(parser)
+
+    adv_opts(parser)
+
+    args = parser.parse_args()
+
+    # Load the hyperparameters from the config file.
+    args = load_hyperparam(args)
+
+    # Build tokenizer.
+    args.tokenizer = str2tokenizer[args.tokenizer](args)
+    set_seed(args.seed)
+
+    model = Regression(args)
+
+    # Load or initialize parameters.
+    load_or_initialize_parameters(args, model)
+
+    # Get logger.
+    args.logger = init_logger(args)
+
+    args.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(args.device)
+
+    # Training phase.
+    trainset = read_dataset(args, args.train_path)
+    instances_num = len(trainset)
+    batch_size = args.batch_size
+
+    args.train_steps = int(instances_num * args.epochs_num / batch_size) + 1
+
+    args.logger.info("Batch size: {}".format(batch_size))
+    args.logger.info("The number of training instances: {}".format(instances_num))
+    optimizer, scheduler = build_optimizer(args, model)
+
+    if args.fp16:
+        try:
+            from apex import amp
+        except ImportError:
+            raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
+        model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level)
+        args.amp = amp
+
+    if torch.cuda.device_count() > 1:
+        args.logger.info("{} GPUs are available. Let's use them.".format(torch.cuda.device_count()))
+        model = torch.nn.DataParallel(model)
+    args.model = model
+
+    if args.use_adv:
+        args.adv_method = str2adv[args.adv_type](model)
+
+    total_loss, result, best_result = 0.0, 0.0, 0.0
+
+    args.logger.info("Start training.")
+    for epoch in range(1, args.epochs_num + 1):
+        random.shuffle(trainset)
+        src = torch.LongTensor([example[0] for example in trainset])
+        tgt = torch.FloatTensor([example[1] for example in trainset])
+        seg = torch.LongTensor([example[2] for example in trainset])
+
+        model.train()
+        for i, (src_batch, tgt_batch, seg_batch, _) in enumerate(batch_loader(batch_size, src, tgt, seg, None)):
+            loss = train_model(args, model, optimizer, scheduler, src_batch, tgt_batch, seg_batch, None)
+            total_loss += loss.item()
+            if (i + 1) % args.report_steps == 0:
+                args.logger.info("Epoch id: {}, Training steps: {}, Avg loss: {:.3f}".format(epoch, i + 1, total_loss / args.report_steps))
+                total_loss = 0.0
+
+        result = evaluate(args, read_dataset(args, args.dev_path))
+        if result > best_result:
+            best_result = result
+            save_model(model, args.output_model_path)
+
+    # Evaluation phase.
+    if args.test_path is not None:
+        args.logger.info("Test set evaluation.")
+        if torch.cuda.device_count() > 1:
+            args.model.module.load_state_dict(torch.load(args.output_model_path))
+        else:
+            args.model.load_state_dict(torch.load(args.output_model_path))
+        evaluate(args, read_dataset(args, args.test_path))
+
+
+if __name__ == "__main__":
+    main()

train/finetune/run_simcse.py

@@ -0,0 +1,274 @@
+"""
+This script provides an example to wrap TencentPretrain for SimCSE.
+"""
+import sys
+import os
+import random
+import argparse
+import math
+import scipy.stats
+import torch
+import torch.nn as nn
+import numpy as np
+
+tencentpretrain_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(tencentpretrain_dir)
+
+from tencentpretrain.embeddings import *
+from tencentpretrain.encoders import *
+from tencentpretrain.targets import *
+from tencentpretrain.utils.vocab import Vocab
+from tencentpretrain.utils.constants import *
+from tencentpretrain.utils import *
+from tencentpretrain.utils.optimizers import *
+from tencentpretrain.utils.config import load_hyperparam
+from tencentpretrain.utils.seed import set_seed
+from tencentpretrain.utils.logging import init_logger
+from tencentpretrain.model_saver import save_model
+from tencentpretrain.opts import finetune_opts, tokenizer_opts
+from finetune.run_classifier import count_labels_num, build_optimizer, load_or_initialize_parameters
+from finetune.run_classifier_siamese import batch_loader
+
+
+class SimCSE(nn.Module):
+    def __init__(self, args):
+        super(SimCSE, self).__init__()
+        self.embedding = Embedding(args)
+        for embedding_name in args.embedding:
+            tmp_emb = str2embedding[embedding_name](args, len(args.tokenizer.vocab))
+            self.embedding.update(tmp_emb, embedding_name)
+        self.encoder = str2encoder[args.encoder](args)
+
+        self.pooling_type = args.pooling
+
+    def forward(self, src, seg):
+        """
+        Args:
+            src: [batch_size x seq_length]
+            tgt: [batch_size]
+            seg: [batch_size x seq_length]
+        """
+        # Embedding.
+        emb_0 = self.embedding(src[0], seg[0])
+        emb_1 = self.embedding(src[1], seg[1])
+        # Encoder.
+        output_0 = self.encoder(emb_0, seg[0])
+        output_1 = self.encoder(emb_1, seg[1])
+        # Target.
+        features_0 = self.pooling(output_0, seg[0], self.pooling_type)
+        features_1 = self.pooling(output_1, seg[1], self.pooling_type)
+
+        return features_0, features_1
+
+    def pooling(self, memory_bank, seg, pooling_type):
+        seg = torch.unsqueeze(seg, dim=-1).type(torch.float)
+        memory_bank = memory_bank * seg
+        if pooling_type == "mean":
+            features = torch.sum(memory_bank, dim=1)
+            features = torch.div(features, torch.sum(seg, dim=1))
+        elif pooling_type == "last":
+            features = memory_bank[torch.arange(memory_bank.shape[0]), torch.squeeze(torch.sum(seg, dim=1).type(torch.int64) - 1), :]
+        elif pooling_type == "max":
+            features = torch.max(memory_bank + (seg - 1) * sys.maxsize, dim=1)[0]
+        else:
+            features = memory_bank[:, 0, :]
+        return features
+
+
+def read_dataset(args, path):
+    dataset, columns = [], {}
+    with open(path, mode="r", encoding="utf-8") as f:
+        for line_id, line in enumerate(f):
+            if line_id == 0:
+                for i, column_name in enumerate(line.rstrip("\r\n").split("\t")):
+                    columns[column_name] = i
+                continue
+            line = line.rstrip("\r\n").split("\t")
+
+            if "text_b" in columns:
+                text_a, text_b = line[columns["text_a"]], line[columns["text_b"]]
+            else:
+                text_a = line[columns["text_a"]]
+                text_b = text_a
+            src_a = args.tokenizer.convert_tokens_to_ids([CLS_TOKEN] + args.tokenizer.tokenize(text_a) + [SEP_TOKEN])
+            src_b = args.tokenizer.convert_tokens_to_ids([CLS_TOKEN] + args.tokenizer.tokenize(text_b) + [SEP_TOKEN])
+            seg_a = [1] * len(src_a)
+            seg_b = [1] * len(src_b)
+            PAD_ID = args.tokenizer.convert_tokens_to_ids([PAD_TOKEN])[0]
+
+            if len(src_a) >= args.seq_length:
+                src_a = src_a[:args.seq_length]
+                seg_a = seg_a[:args.seq_length]
+            while len(src_a) < args.seq_length:
+                src_a.append(PAD_ID)
+                seg_a.append(0)
+
+            if len(src_b) >= args.seq_length:
+                src_b = src_b[:args.seq_length]
+                seg_b = seg_b[:args.seq_length]
+            while len(src_b) < args.seq_length:
+                src_b.append(PAD_ID)
+                seg_b.append(0)
+
+            if "label" in columns:
+                tgt = float(line[columns["label"]])
+                dataset.append(((src_a, src_b), tgt, (seg_a, seg_b)))
+            else:
+                dataset.append(((src_a, src_a), -1, (seg_a, seg_a)))
+    return dataset
+
+
+def evaluate(args, dataset):
+    src_a = torch.LongTensor([example[0][0] for example in dataset])
+    src_b = torch.LongTensor([example[0][1] for example in dataset])
+    tgt = torch.FloatTensor([example[1] for example in dataset])
+    seg_a = torch.LongTensor([example[2][0] for example in dataset])
+    seg_b = torch.LongTensor([example[2][1] for example in dataset])
+
+    all_similarities = []
+    batch_size = args.batch_size
+    args.model.eval()
+
+    for i, (src_batch, tgt_batch, seg_batch) in enumerate(batch_loader(batch_size, (src_a, src_b), tgt, (seg_a, seg_b))):
+
+        src_a_batch, src_b_batch = src_batch
+        seg_a_batch, seg_b_batch = seg_batch
+
+        src_a_batch = src_a_batch.to(args.device)
+        src_b_batch = src_b_batch.to(args.device)
+
+        seg_a_batch = seg_a_batch.to(args.device)
+        seg_b_batch = seg_b_batch.to(args.device)
+
+        with torch.no_grad():
+            features_0, features_1 = args.model((src_a_batch, src_b_batch), (seg_a_batch, seg_b_batch))
+        similarity_matrix = similarity(features_0, features_1, 1)
+
+        for j in range(similarity_matrix.size(0)):
+            all_similarities.append(similarity_matrix[j][j].item())
+
+    corrcoef = scipy.stats.spearmanr(tgt, all_similarities).correlation
+    args.logger.info("Spearman's correlation: {:.4f}".format(corrcoef))
+    return corrcoef
+
+
+def similarity(x, y, temperature):
+    x = x / x.norm(dim=-1, keepdim=True)
+    y = y / y.norm(dim=-1, keepdim=True)
+    return torch.matmul(x, y.transpose(-2, -1)) / temperature
+
+
+def main():
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    finetune_opts(parser)
+
+    tokenizer_opts(parser)
+
+    parser.add_argument("--temperature", type=float, default=0.05)
+    parser.add_argument("--eval_steps", type=int, default=200, help="Evaluate frequency.")
+
+    args = parser.parse_args()
+
+    # Load the hyperparameters from the config file.
+    args = load_hyperparam(args)
+
+    set_seed(args.seed)
+
+    # Build tokenizer.
+    args.tokenizer = str2tokenizer[args.tokenizer](args)
+
+    # Build classification model.
+    model = SimCSE(args)
+
+    # Load or initialize parameters.
+    load_or_initialize_parameters(args, model)
+
+    # Get logger.
+    args.logger = init_logger(args)
+
+    args.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(args.device)
+
+    # Training phase.
+    trainset = read_dataset(args, args.train_path)
+    instances_num = len(trainset)
+    batch_size = args.batch_size
+
+    args.train_steps = int(instances_num * args.epochs_num / batch_size) + 1
+
+    args.logger.info("Batch size: {}".format(batch_size))
+    args.logger.info("The number of training instances: {}".format(instances_num))
+
+    optimizer, scheduler = build_optimizer(args, model)
+
+    if args.fp16:
+        try:
+            from apex import amp
+        except ImportError:
+            raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
+        model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level)
+        args.amp = amp
+
+    if torch.cuda.device_count() > 1:
+        args.logger.info("{} GPUs are available. Let's use them.".format(torch.cuda.device_count()))
+        model = torch.nn.DataParallel(model)
+    args.model = model
+
+    total_loss, result, best_result = 0.0, 0.0, 0.0
+
+    args.logger.info("Start training.")
+    for epoch in range(1, args.epochs_num + 1):
+        random.shuffle(trainset)
+        src_a = torch.LongTensor([example[0][0] for example in trainset])
+        src_b = torch.LongTensor([example[0][1] for example in trainset])
+        tgt = torch.FloatTensor([example[1] for example in trainset])
+        seg_a = torch.LongTensor([example[2][0] for example in trainset])
+        seg_b = torch.LongTensor([example[2][1] for example in trainset])
+
+        model.train()
+        for i, (src_batch, tgt_batch, seg_batch) in enumerate(batch_loader(batch_size, (src_a, src_b), tgt, (seg_a, seg_b))):
+            model.zero_grad()
+
+            src_a_batch, src_b_batch = src_batch
+            seg_a_batch, seg_b_batch = seg_batch
+
+            src_a_batch = src_a_batch.to(args.device)
+            src_b_batch = src_b_batch.to(args.device)
+
+            seg_a_batch = seg_a_batch.to(args.device)
+            seg_b_batch = seg_b_batch.to(args.device)
+
+            features_0, features_1 = model((src_a_batch, src_b_batch), (seg_a_batch, seg_b_batch))
+
+            similarity_matrix = similarity(features_0, features_1, args.temperature)
+            tgt_batch = torch.arange(similarity_matrix.size(0), device=similarity_matrix.device, dtype=torch.long)
+            loss = nn.CrossEntropyLoss()(similarity_matrix, tgt_batch)
+
+            if args.fp16:
+                with args.amp.scale_loss(loss, optimizer) as scaled_loss:
+                    scaled_loss.backward()
+            else:
+                loss.backward()
+
+            optimizer.step()
+            scheduler.step()
+
+            total_loss += loss.item()
+            if (i + 1) % args.report_steps == 0:
+                args.logger.info("Epoch id: {}, Training steps: {}, Avg loss: {:.3f}"
+                                 .format(epoch, i + 1, total_loss / args.report_steps))
+                total_loss = 0.0
+
+            if (i + 1) % args.eval_steps == 0 or (i + 1) == math.ceil(instances_num / batch_size):
+                result = evaluate(args, read_dataset(args, args.dev_path))
+                args.logger.info("Epoch id: {}, Training steps: {}, Evaluate result: {}, Best result: {}"
+                                 .format(epoch, i + 1, result, best_result))
+                if result > best_result:
+                    best_result = result
+                    save_model(model, args.output_model_path)
+                    args.logger.info("It is the best model until now. Save it to {}".format(args.output_model_path))
+
+
+if __name__ == "__main__":
+    main()

train/finetune/run_speech2text.py

@@ -0,0 +1,311 @@
+"""
+This script provides an example to wrap TencentPretrain for speech-to-text fine-tuning.
+"""
+import sys
+import os
+import random
+import argparse
+import editdistance
+import torch
+import torchaudio
+import torchaudio.compliance.kaldi as ta_kaldi
+
+tencentpretrain_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(tencentpretrain_dir)
+
+from tencentpretrain.model_saver import save_model
+from tencentpretrain.decoders import *
+from tencentpretrain.targets import *
+from tencentpretrain.utils import utterance_cmvn
+from finetune.run_classifier import *
+
+
+class Speech2text(torch.nn.Module):
+    def __init__(self, args):
+        super(Speech2text, self).__init__()
+        self.embedding = Embedding(args)
+        for embedding_name in args.embedding:
+            tmp_emb = str2embedding[embedding_name](args, len(args.tokenizer.vocab))
+            self.embedding.update(tmp_emb, embedding_name)
+        self.encoder = str2encoder[args.encoder](args)
+        self.tgt_embedding = Embedding(args)
+        for embedding_name in args.tgt_embedding:
+            tmp_emb = str2embedding[embedding_name](args, len(args.tokenizer.vocab))
+            self.tgt_embedding.update(tmp_emb, embedding_name)
+        self.decoder = str2decoder[args.decoder](args)
+        self.target = Target()
+        for target_name in args.target:
+            tmp_target = str2target[target_name](args, len(args.tokenizer.vocab))
+            self.target.update(tmp_target, target_name)
+        if args.tie_weights:
+            self.target.lm.output_layer.weight = self.tgt_embedding.word.embedding.weight
+
+    def encode(self, src, seg):
+        emb = self.embedding(src, seg)
+        memory_bank = self.encoder(emb, seg)
+        return memory_bank, emb
+
+    def decode(self, emb, memory_bank, tgt, tgt_seg):
+        tgt_in, tgt_out, _ = tgt
+        decoder_emb = self.tgt_embedding(tgt_in, tgt_seg)
+        hidden = self.decoder(memory_bank, decoder_emb, [emb.abs()[:,:,0]])
+        output = self.target.lm.output_layer(hidden)
+        return output
+
+    def forward(self, src, tgt, seg, tgt_seg, memory_bank=None, only_use_encoder=False):
+        if only_use_encoder:
+            return self.encode(src, seg)
+        if memory_bank is not None:
+            emb = src
+            return self.decode(emb, memory_bank, tgt, tgt_seg)
+        tgt_in, tgt_out, _ = tgt
+        memory_bank, emb = self.encode(src, seg)
+        
+        if tgt_out is None:
+            output = self.decode(emb, memory_bank, tgt, None)
+            return None, output
+        else:
+            decoder_emb = self.tgt_embedding(tgt_in, tgt_seg)
+            hidden = self.decoder(memory_bank, decoder_emb, (seg,))
+            loss = self.target(hidden, tgt_out, None)[0]
+            return loss, None
+
+
+def read_dataset(args, path):
+    dataset, columns = [], {}
+    padding_vector = torch.FloatTensor(args.audio_feature_size * [0.0] if args.audio_feature_size > 1 else 0.0).unsqueeze(0)
+
+    with open(path, mode="r", encoding="utf-8") as f:
+        for line_id, line in enumerate(f):
+            if line_id == 0:
+                for i, column_name in enumerate(line.rstrip("\r\n").split("\t")):
+                    columns[column_name] = i
+                continue
+            line = line.rstrip("\r\n").split("\t")
+            text, wav_path = line[columns["text"]], line[columns["wav_path"]]
+            tgt = args.tokenizer.convert_tokens_to_ids([CLS_TOKEN]) + \
+                args.tokenizer.convert_tokens_to_ids(args.tokenizer.tokenize(text)) + \
+                args.tokenizer.convert_tokens_to_ids([SEP_TOKEN])
+
+            if len(tgt) > args.seq_length:
+                tgt = tgt[: args.seq_length]
+
+            PAD_ID = args.tokenizer.convert_tokens_to_ids([PAD_TOKEN])
+            pad_num = args.seq_length - len(tgt)
+            tgt = tgt + PAD_ID * pad_num
+
+            waveform, sample_rate = torchaudio.load(wav_path)
+            waveform = waveform * (2 ** 15)  # Kaldi compliance: 16-bit signed integers
+            feature = ta_kaldi.fbank(waveform, num_mel_bins=args.audio_feature_size, sample_frequency=sample_rate)
+            if "ceptral_normalize" in args.audio_preprocess:
+                feature = utterance_cmvn(feature)
+            difference = args.max_audio_frames - feature.size(0)
+
+            if difference < 0:
+                continue
+            else:
+                src_audio = torch.cat([feature] + [padding_vector] * difference)
+                seg_audio = [1] * int(feature.size(0) / args.conv_layers_num / 2) + [0] * (int(args.max_audio_frames /args.conv_layers_num / 2) - int(feature.size(0) / args.conv_layers_num / 2))
+
+            tgt_in = tgt[:-1]
+            tgt_out = tgt[1:]
+            tgt_seg = [1] * (len(tgt[1:]) - pad_num) + [0] * pad_num
+
+            dataset.append((src_audio, tgt_in, tgt_out, seg_audio, tgt_seg))
+
+    return dataset
+
+
+def batch_loader(batch_size, src, tgt_in, tgt_out, seg, tgt_seg):
+    instances_num = src.size()[0]
+    for i in range(instances_num // batch_size):
+        src_batch = src[i * batch_size : (i + 1) * batch_size, :]
+        tgt_in_batch = tgt_in[i * batch_size : (i + 1) * batch_size, :]
+        tgt_out_batch = tgt_out[i * batch_size : (i + 1) * batch_size, :]
+        seg_batch = seg[i * batch_size : (i + 1) * batch_size, :]
+        tgt_seg_batch = tgt_seg[i * batch_size : (i + 1) * batch_size, :]
+        yield src_batch, tgt_in_batch, tgt_out_batch, seg_batch, tgt_seg_batch
+
+    if instances_num > instances_num // batch_size * batch_size:
+        src_batch = src[instances_num // batch_size * batch_size :, :]
+        tgt_in_batch = tgt_in[instances_num // batch_size * batch_size :, :]
+        tgt_out_batch = tgt_out[instances_num // batch_size * batch_size :, :]
+        seg_batch = seg[instances_num // batch_size * batch_size :, :]
+        tgt_seg_batch = tgt_seg[instances_num // batch_size * batch_size :, :]
+        yield src_batch, tgt_in_batch, tgt_out_batch, seg_batch, tgt_seg_batch
+
+
+def train_model(args, model, optimizer, scheduler, src_batch, tgt_in_batch, tgt_out_batch, seg_batch, tgt_seg_batch):
+    model.zero_grad()
+
+    src_batch = src_batch.to(args.device)
+    tgt_in_batch = tgt_in_batch.to(args.device)
+    tgt_out_batch = tgt_out_batch.to(args.device)
+    seg_batch = seg_batch.to(args.device)
+    tgt_seg_batch = tgt_seg_batch.to(args.device)
+
+    loss, _ = model(src_batch, (tgt_in_batch, tgt_out_batch, src_batch), seg_batch, tgt_seg_batch)
+
+    if torch.cuda.device_count() > 1:
+        loss = torch.mean(loss)
+
+    if args.fp16:
+        with args.amp.scale_loss(loss, optimizer) as scaled_loss:
+            scaled_loss.backward()
+    else:
+        loss.backward()
+
+    optimizer.step()
+    scheduler.step()
+
+    return loss
+
+
+def evaluate(args, dataset):
+
+    src = torch.stack([example[0] for example in dataset], dim=0)
+    tgt_in = torch.LongTensor([example[1] for example in dataset])
+    tgt_out = torch.LongTensor([example[2] for example in dataset])
+    seg = torch.LongTensor([example[3] for example in dataset])
+    tgt_seg = torch.LongTensor([example[4] for example in dataset])
+
+    generated_sentences = []
+    args.model.eval()
+
+    for i, (src_batch, tgt_in_batch, tgt_out_batch, seg_batch, tgt_seg_batch) in enumerate(batch_loader(args.batch_size, src, tgt_in, tgt_out, seg, tgt_seg)):
+
+        src_batch = src_batch.to(args.device)
+        tgt_in_batch = torch.zeros(tgt_in_batch.size()[0], 1, dtype=torch.long, device=args.device)
+        tgt_seg_batch  = torch.ones(tgt_in_batch.size()[0], 1, dtype=torch.long, device=args.device)
+        for j in range(tgt_in_batch.size()[0]):
+            tgt_in_batch[j][0] = args.tokenizer.vocab.get(CLS_TOKEN)
+
+        seg_batch = seg_batch.to(args.device)
+
+        with torch.no_grad():
+            memory_bank, emb = args.model(src_batch, None, seg_batch, tgt_seg_batch, only_use_encoder=True)
+
+        for _ in range(args.tgt_seq_length):
+            tgt_out_batch = tgt_in_batch
+            with torch.no_grad():
+                outputs = args.model(emb, (tgt_in_batch, tgt_out_batch, src_batch), None, tgt_seg_batch, memory_bank=memory_bank)
+
+            next_token_logits = outputs[:, -1]
+            next_tokens = torch.argmax(next_token_logits, dim=1).unsqueeze(1)
+            tgt_in_batch = torch.cat([tgt_in_batch, next_tokens], dim=1)
+            tgt_seg_batch  = torch.ones(tgt_in_batch.size()[0], tgt_in_batch.size()[1], dtype=torch.long, device=args.device)
+        for j in range(len(outputs)):
+            sentence = "".join([args.tokenizer.inv_vocab[token_id.item()] for token_id in tgt_in_batch[j][1:]])
+            generated_sentences.append(sentence)
+
+    w_errs = 0
+    w_total = 0
+
+    for i, example in enumerate(dataset):
+        tgt = example[2]
+        tgt_token = "".join([args.tokenizer.inv_vocab[token_id] for token_id in tgt[:-2]])
+        generated_sentences[i] = generated_sentences[i].split(SEP_TOKEN)[0]
+
+        pred = generated_sentences[i].split("▁")
+        gold = tgt_token.split(SEP_TOKEN)[0].split("▁")
+        w_errs += editdistance.eval(pred, gold)
+        w_total += len(gold)
+
+    args.logger.info("WER. (Word_Errors/Total): {:.4f} ({}/{}) ".format(w_errs / w_total, w_errs, w_total))
+    return w_errs / w_total
+
+
+def main():
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    finetune_opts(parser)
+
+    tokenizer_opts(parser)
+
+    parser.add_argument("--tgt_seq_length", type=int, default=50,
+                        help="Output sequence length.")
+
+    args = parser.parse_args()
+
+    # Load the hyperparameters from the config file.
+    args = load_hyperparam(args)
+
+    set_seed(args.seed)
+
+    # Build tokenizer.
+    args.tokenizer = str2tokenizer[args.tokenizer](args)
+
+    # Build classification model.
+    model = Speech2text(args)
+
+    # Load or initialize parameters.
+    load_or_initialize_parameters(args, model)
+
+    # Get logger.
+    args.logger = init_logger(args)
+
+    args.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(args.device)
+
+    # Training phase.
+    trainset = read_dataset(args, args.train_path)
+    instances_num = len(trainset)
+    batch_size = args.batch_size
+
+    args.train_steps = int(instances_num * args.epochs_num / batch_size) + 1
+
+    args.logger.info("Batch size: {}".format(batch_size))
+    args.logger.info("The number of training instances: {}".format(instances_num))
+
+    optimizer, scheduler = build_optimizer(args, model)
+
+    if args.fp16:
+        try:
+            from apex import amp
+        except ImportError:
+            raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
+        model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level)
+        args.amp = amp
+
+    if torch.cuda.device_count() > 1:
+        args.logger.info("{} GPUs are available. Let's use them.".format(torch.cuda.device_count()))
+        model = torch.nn.DataParallel(model)
+    args.model = model
+
+    total_loss, result, best_result = 0.0, 0.0, 100.0
+
+    args.logger.info("Start training.")
+
+    for epoch in range(1, args.epochs_num + 1):
+        random.shuffle(trainset)
+        src = torch.stack([example[0] for example in trainset], dim=0)
+        tgt_in = torch.LongTensor([example[1] for example in trainset])
+        tgt_out = torch.LongTensor([example[2] for example in trainset])
+        seg = torch.LongTensor([example[3] for example in trainset])
+        tgt_seg = torch.LongTensor([example[4] for example in trainset])
+
+        model.train()
+        for i, (src_batch, tgt_in_batch, tgt_out_batch, seg_batch, tgt_seg_batch) in enumerate(batch_loader(batch_size, src, tgt_in, tgt_out, seg, tgt_seg)):
+            loss = train_model(args, model, optimizer, scheduler, src_batch, tgt_in_batch, tgt_out_batch, seg_batch, tgt_seg_batch)
+            total_loss += loss.item()
+            if (i + 1) % args.report_steps == 0:
+                args.logger.info("Epoch id: {}, Training steps: {}, Avg loss: {:.3f}".format(epoch, i + 1, total_loss / args.report_steps))
+                total_loss = 0.0
+
+        result = evaluate(args, read_dataset(args, args.dev_path))
+        if result < best_result:
+            best_result = result
+            save_model(model, args.output_model_path)
+
+    # Evaluation phase.
+    if args.test_path is not None:
+        args.logger.info("Test set evaluation.")
+        if torch.cuda.device_count() > 1:
+            args.model.module.load_state_dict(torch.load(args.output_model_path))
+        else:
+            args.model.load_state_dict(torch.load(args.output_model_path))
+        evaluate(args, read_dataset(args, args.test_path))
+
+
+if __name__ == "__main__":
+    main()

train/finetune/run_text2text.py

@@ -0,0 +1,314 @@
+"""
+This script provides an example to wrap TencentPretrain for text-to-text fine-tuning.
+"""
+import sys
+import os
+import random
+import argparse
+import torch
+
+tencentpretrain_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(tencentpretrain_dir)
+
+from tencentpretrain.model_saver import save_model
+from tencentpretrain.decoders import *
+from tencentpretrain.targets import *
+from finetune.run_classifier import *
+
+
+class Text2text(torch.nn.Module):
+    def __init__(self, args):
+        super(Text2text, self).__init__()
+        self.embedding = Embedding(args)
+        for embedding_name in args.embedding:
+            tmp_emb = str2embedding[embedding_name](args, len(args.tokenizer.vocab))
+            self.embedding.update(tmp_emb, embedding_name)
+        self.encoder = str2encoder[args.encoder](args)
+        self.tgt_embedding = Embedding(args)
+        for embedding_name in args.tgt_embedding:
+            tmp_emb = str2embedding[embedding_name](args, len(args.tokenizer.vocab))
+            self.tgt_embedding.update(tmp_emb, embedding_name)
+        self.decoder = str2decoder[args.decoder](args)
+        self.target = Target()
+        self.target.update(LmTarget(args, len(args.tokenizer.vocab)), "lm")
+        if args.tie_weights:
+            self.target.lm.output_layer.weight = self.embedding.word.embedding.weight
+        if args.share_embedding:
+            self.tgt_embedding.word.embedding.weight = self.embedding.word.embedding.weight
+
+    def encode(self, src, seg):
+        emb = self.embedding(src, seg)
+        memory_bank = self.encoder(emb, seg)
+        return memory_bank
+
+    def decode(self, src, memory_bank, tgt, tgt_seg):
+        tgt_in, tgt_out, _ = tgt
+        decoder_emb = self.tgt_embedding(tgt_in, tgt_seg)
+        hidden = self.decoder(memory_bank, decoder_emb, (src,))
+        output = self.target.lm.output_layer(hidden)
+        return output
+
+    def forward(self, src, tgt, seg, tgt_seg, memory_bank=None, only_use_encoder=False):
+        if only_use_encoder:
+            return self.encode(src, seg)
+        if memory_bank is not None:
+            return self.decode(src, memory_bank, tgt, tgt_seg)
+        tgt_in, tgt_out, _ = tgt
+        memory_bank = self.encode(src, seg)
+        if tgt_out is None:
+            output = self.decode(src, memory_bank, tgt)
+            return None, output
+        else:
+            decoder_emb = self.tgt_embedding(tgt_in, tgt_seg)
+            hidden = self.decoder(memory_bank, decoder_emb, (seg,))
+            loss = self.target(hidden, tgt_out, None)[0]
+            return loss, None
+
+
+def read_dataset(args, path):
+    dataset, columns = [], {}
+    with open(path, mode="r", encoding="utf-8") as f:
+        for line_id, line in enumerate(f):
+            if line_id == 0:
+                for i, column_name in enumerate(line.rstrip("\r\n").split("\t")):
+                    columns[column_name] = i
+                continue
+            line = line.rstrip("\r\n").split("\t")
+
+            if "text_b" in columns:
+                text = line[columns["text_a"]] + SEP_TOKEN + line[columns["text_b"]]
+                label = line[columns["label"]]
+            else:
+                text, label = line[columns["text_a"]], line[columns["label"]]
+
+            src = args.tokenizer.convert_tokens_to_ids([CLS_TOKEN] + args.tokenizer.tokenize(text) + [SEP_TOKEN])
+            tgt_in = args.tokenizer.convert_tokens_to_ids([CLS_TOKEN] + args.tokenizer.tokenize(label) + [SEP_TOKEN])
+            PAD_ID = args.tokenizer.convert_tokens_to_ids([PAD_TOKEN])[0]
+            seg = [1] * len(src)
+            tgt_seg = [1] * len(tgt_in)
+
+            if len(src) > args.seq_length:
+                src = src[: args.seq_length]
+                seg = seg[: args.seq_length]
+            if len(tgt_in) > args.tgt_seq_length:
+                tgt_in = tgt_in[: args.tgt_seq_length]
+                tgt_seg = tgt_seg[: args.tgt_seq_length]
+            tgt_out = tgt_in[1:] + [PAD_ID]
+
+            while len(src) < args.seq_length:
+                src.append(PAD_ID)
+                seg.append(0)
+            while len(tgt_in) < args.tgt_seq_length:
+                tgt_in.append(PAD_ID)
+                tgt_out.append(PAD_ID)
+                tgt_seg.append(PAD_ID)
+
+            dataset.append((src, tgt_in, tgt_out, seg, tgt_seg))
+
+    return dataset
+
+
+def batch_loader(batch_size, src, tgt_in, tgt_out, seg, tgt_seg):
+    instances_num = src.size()[0]
+    for i in range(instances_num // batch_size):
+        src_batch = src[i * batch_size : (i + 1) * batch_size, :]
+        tgt_in_batch = tgt_in[i * batch_size : (i + 1) * batch_size, :]
+        tgt_out_batch = tgt_out[i * batch_size : (i + 1) * batch_size, :]
+        seg_batch = seg[i * batch_size : (i + 1) * batch_size, :]
+        tgt_seg_batch = tgt_seg[i * batch_size : (i + 1) * batch_size, :]
+        yield src_batch, tgt_in_batch, tgt_out_batch, seg_batch, tgt_seg_batch
+
+    if instances_num > instances_num // batch_size * batch_size:
+        src_batch = src[instances_num // batch_size * batch_size :, :]
+        tgt_in_batch = tgt_in[instances_num // batch_size * batch_size :, :]
+        tgt_out_batch = tgt_out[instances_num // batch_size * batch_size :, :]
+        seg_batch = seg[instances_num // batch_size * batch_size :, :]
+        tgt_seg_batch = tgt_seg[instances_num // batch_size * batch_size :, :]
+        yield src_batch, tgt_in_batch, tgt_out_batch, seg_batch, tgt_seg_batch
+
+
+def train_model(args, model, optimizer, scheduler, src_batch, tgt_in_batch, tgt_out_batch, seg_batch, tgt_seg_batch):
+    model.zero_grad()
+
+    src_batch = src_batch.to(args.device)
+    tgt_in_batch = tgt_in_batch.to(args.device)
+    tgt_out_batch = tgt_out_batch.to(args.device)
+    seg_batch = seg_batch.to(args.device)
+    tgt_seg_batch = tgt_seg_batch.to(args.device)
+
+    loss, _ = model(src_batch, (tgt_in_batch, tgt_out_batch, src_batch), seg_batch, tgt_seg_batch)
+
+    if torch.cuda.device_count() > 1:
+        loss = torch.mean(loss)
+
+    if args.fp16:
+        with args.amp.scale_loss(loss, optimizer) as scaled_loss:
+            scaled_loss.backward()
+    else:
+        loss.backward()
+
+    optimizer.step()
+    scheduler.step()
+
+    return loss
+
+
+def evaluate(args, dataset):
+
+    src = torch.LongTensor([example[0] for example in dataset])
+    tgt_in = torch.LongTensor([example[1] for example in dataset])
+    tgt_out = torch.LongTensor([example[2] for example in dataset])
+    seg = torch.LongTensor([example[3] for example in dataset])
+    tgt_seg = torch.LongTensor([example[4] for example in dataset])
+
+    generated_sentences = []
+    args.model.eval()
+
+    for i, (src_batch, tgt_in_batch, tgt_out_batch, seg_batch, tgt_seg_batch) in enumerate(batch_loader(args.batch_size, src, tgt_in, tgt_out, seg, tgt_seg)):
+
+        src_batch = src_batch.to(args.device)
+        tgt_in_batch = torch.zeros(tgt_in_batch.size()[0], 1, dtype=torch.long, device=args.device)
+        tgt_seg_batch  = torch.ones(tgt_in_batch.size()[0], 1, dtype=torch.long, device=args.device)
+        for j in range(tgt_in_batch.size()[0]):
+            tgt_in_batch[j][-1] = args.tokenizer.vocab.get(CLS_TOKEN)
+
+        seg_batch = seg_batch.to(args.device)
+
+        with torch.no_grad():
+            memory_bank = args.model(src_batch, None, seg_batch, tgt_seg_batch, only_use_encoder=True)
+
+        for _ in range(args.tgt_seq_length):
+            tgt_out_batch = tgt_in_batch
+            with torch.no_grad():
+                outputs = args.model(src_batch, (tgt_in_batch, tgt_out_batch, src_batch), None, tgt_seg_batch, memory_bank=memory_bank)
+
+            next_token_logits = outputs[:, -1]
+            next_tokens = torch.argmax(next_token_logits, dim=1).unsqueeze(1)
+            tgt_in_batch = torch.cat([tgt_in_batch, next_tokens], dim=1)
+            tgt_seg_batch  = torch.ones(tgt_in_batch.size()[0], tgt_in_batch.size()[1], dtype=torch.long, device=args.device)
+        for j in range(len(outputs)):
+            sentence = " ".join([args.tokenizer.inv_vocab[token_id.item()] for token_id in tgt_in_batch[j][1:]])
+            generated_sentences.append(sentence)
+
+    labels = {}
+    labels_num = 0
+    for example in dataset:
+        label = "".join([args.tokenizer.inv_vocab[token_id] for token_id in example[2][:-2]]).split(SEP_TOKEN)[0]
+        if not labels.get(label, None):
+            labels[label] = labels_num
+            labels_num += 1
+    confusion_matrix = torch.zeros(labels_num, labels_num, dtype=torch.long)
+    correct = 0
+
+    for i, example in enumerate(dataset):
+        tgt = example[2]
+        tgt_token = " ".join([args.tokenizer.inv_vocab[token_id] for token_id in tgt[:-2]])
+        generated_sentences[i] = generated_sentences[i].split(SEP_TOKEN)[0]
+
+        pred = "".join(generated_sentences[i].split(" "))
+        gold = "".join(tgt_token.split(SEP_TOKEN)[0].split(" "))
+
+        if pred in labels.keys():
+            confusion_matrix[labels[pred], labels[gold]] += 1
+
+        if pred == gold:
+            correct += 1
+
+    args.logger.info("Acc. (Correct/Total): {:.4f} ({}/{}) ".format(correct / len(dataset), correct, len(dataset)))
+    return correct / len(dataset)
+
+
+def main():
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    finetune_opts(parser)
+
+    tokenizer_opts(parser)
+
+    parser.add_argument("--tgt_seq_length", type=int, default=32,
+                        help="Output sequence length.")
+
+    args = parser.parse_args()
+
+    # Load the hyperparameters from the config file.
+    args = load_hyperparam(args)
+
+    set_seed(args.seed)
+
+    # Build tokenizer.
+    args.tokenizer = str2tokenizer[args.tokenizer](args)
+
+    # Build classification model.
+    model = Text2text(args)
+
+    # Load or initialize parameters.
+    load_or_initialize_parameters(args, model)
+
+    # Get logger.
+    args.logger = init_logger(args)
+
+    args.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(args.device)
+
+    # Training phase.
+    trainset = read_dataset(args, args.train_path)
+    instances_num = len(trainset)
+    batch_size = args.batch_size
+
+    args.train_steps = int(instances_num * args.epochs_num / batch_size) + 1
+
+    args.logger.info("Batch size: {}".format(batch_size))
+    args.logger.info("The number of training instances: {}".format(instances_num))
+
+    optimizer, scheduler = build_optimizer(args, model)
+
+    if args.fp16:
+        try:
+            from apex import amp
+        except ImportError:
+            raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
+        model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level)
+        args.amp = amp
+
+    if torch.cuda.device_count() > 1:
+        args.logger.info("{} GPUs are available. Let's use them.".format(torch.cuda.device_count()))
+        model = torch.nn.DataParallel(model)
+    args.model = model
+
+    total_loss, result, best_result = 0.0, 0.0, 0.0
+
+    args.logger.info("Start training.")
+
+    for epoch in range(1, args.epochs_num + 1):
+        random.shuffle(trainset)
+        src = torch.LongTensor([example[0] for example in trainset])
+        tgt_in = torch.LongTensor([example[1] for example in trainset])
+        tgt_out = torch.LongTensor([example[2] for example in trainset])
+        seg = torch.LongTensor([example[3] for example in trainset])
+        tgt_seg = torch.LongTensor([example[4] for example in trainset])
+
+        model.train()
+        for i, (src_batch, tgt_in_batch, tgt_out_batch, seg_batch, tgt_seg_batch) in enumerate(batch_loader(batch_size, src, tgt_in, tgt_out, seg, tgt_seg)):
+            loss = train_model(args, model, optimizer, scheduler, src_batch, tgt_in_batch, tgt_out_batch, seg_batch, tgt_seg_batch)
+            total_loss += loss.item()
+            if (i + 1) % args.report_steps == 0:
+                args.logger.info("Epoch id: {}, Training steps: {}, Avg loss: {:.3f}".format(epoch, i + 1, total_loss / args.report_steps))
+                total_loss = 0.0
+
+        result = evaluate(args, read_dataset(args, args.dev_path))
+        if result > best_result:
+            best_result = result
+            save_model(model, args.output_model_path)
+
+    # Evaluation phase.
+    if args.test_path is not None:
+        args.logger.info("Test set evaluation.")
+        if torch.cuda.device_count() > 1:
+            args.model.module.load_state_dict(torch.load(args.output_model_path))
+        else:
+            args.model.load_state_dict(torch.load(args.output_model_path))
+        evaluate(args, read_dataset(args, args.test_path))
+
+
+if __name__ == "__main__":
+    main()

train/inference/run_c3_infer.py

@@ -0,0 +1,94 @@
+"""
+  This script provides an example to wrap TencentPretrain for C3 (a multiple choice dataset) inference.
+"""
+import sys
+import os
+import argparse
+import torch
+import torch.nn as nn
+
+tencentpretrain_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(tencentpretrain_dir)
+
+from tencentpretrain.utils.constants import *
+from tencentpretrain.utils import *
+from tencentpretrain.utils.config import load_hyperparam
+from tencentpretrain.model_loader import load_model
+from tencentpretrain.opts import infer_opts, tokenizer_opts
+from finetune.run_classifier import batch_loader
+from finetune.run_c3 import MultipleChoice, read_dataset
+
+
+def main():
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    infer_opts(parser)
+
+    parser.add_argument("--max_choices_num", default=4, type=int,
+                        help="The maximum number of cadicate answer, shorter than this will be padded.")
+
+    tokenizer_opts(parser)
+
+    args = parser.parse_args()
+
+    # Load the hyperparameters from the config file.
+    args = load_hyperparam(args)
+
+    # Build tokenizer.
+    args.tokenizer = str2tokenizer[args.tokenizer](args)
+
+    # Build classification model and load parameters.
+    model = MultipleChoice(args)
+    model = load_model(model, args.load_model_path)
+
+    # For simplicity, we use DataParallel wrapper to use multiple GPUs.
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(device)
+    if torch.cuda.device_count() > 1:
+        print("{} GPUs are available. Let's use them.".format(torch.cuda.device_count()))
+        model = torch.nn.DataParallel(model)
+
+    dataset = read_dataset(args, args.test_path)
+
+    src = torch.LongTensor([example[0] for example in dataset])
+    tgt = torch.LongTensor([example[1] for example in dataset])
+    seg = torch.LongTensor([example[2] for example in dataset])
+
+    batch_size = args.batch_size
+    instances_num = src.size()[0]
+
+    print("The number of prediction instances: ", instances_num)
+
+    model.eval()
+
+    with open(args.test_path) as f:
+        data = json.load(f)
+
+    question_ids = []
+    for i in range(len(data)):
+        questions = data[i][1]
+        for question in questions:
+            question_ids.append(question["id"])
+
+    index = 0
+    with open(args.prediction_path, "w") as f:
+        for i, (src_batch, _, seg_batch, _) in enumerate(batch_loader(batch_size, src, tgt, seg)):
+
+            src_batch = src_batch.to(device)
+            seg_batch = seg_batch.to(device)
+
+            with torch.no_grad():
+                _, logits = model(src_batch, None, seg_batch)
+
+                pred = (torch.argmax(logits, dim=1)).cpu().numpy().tolist()
+                for j in range(len(pred)):
+                    output = {}
+                    output["id"] = question_ids[index]
+                    index += 1
+                    output["label"] = int(pred[j])
+                    f.write(json.dumps(output))
+                    f.write("\n")
+
+
+if __name__ == "__main__":
+    main()