from __future__ import absolute_import

from __future__ import division

from __future__ import print_function

import os

import sys

import json

import torch

import logging

import random

import numpy as np

from tqdm import tqdm, trange

from argparse import ArgumentParser

from torch.utils.data import DataLoader, RandomSampler, SequentialSampler

from torch.utils.data.distributed import DistributedSampler

from transformers import BertForSequenceClassification, BertTokenizer, AdamW

from data_process import processors, num_labels_task, convert_examples_to_features, convert_features_to_dataset

# Silent unimportant log messages

for logger_name in ['transformers.configuration_utils',

'transformers.modeling_utils',

'transformers.tokenization_utils_base', 'absl']:

logging.getLogger(logger_name).setLevel(logging.ERROR)

logging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s - %(message)s',

datefmt='%m/%d/%Y %H:%M:%S',

level=logging.INFO)

logger = logging.getLogger(__name__)

def main(args):

"***** Eval results for {0}: {1} *****".format(eval_segment, eval_result))

if __name__ == "__main__":

parser = ArgumentParser()

# Required parameters

parser.add_argument("--data_dir",

default=None,

type=str,

required=True,

help="The input data dir. Should contain the .tsv files (or other data files) for the task.")

parser.add_argument("--task_name",

default=None,

type=str,

required=True,

help="The name of the task to train.")

parser.add_argument("--do_train",

default=False,

action='store_true',

help="Whether to run training.")

parser.add_argument("--do_eval",

default=False,

action='store_true',

help="Whether to run eval on the dev set.")

# Other parameters

parser.add_argument("--bert_model",

default="./bert-base-uncased/",

type=str,

help="Bert pre-trained model selected in the list: bert-base-uncased, "

"bert-large-uncased, bert-base-cased, bert-base-multilingual, bert-base-chinese.")

parser.add_argument("--output_dir",

default="./ckpt",

type=str,

help="The output directory where the model predictions and checkpoints will be written.")

parser.add_argument("--model_recover_path",

default=None,

type=str,

help="The file of fine-tuned pretraining model.")

parser.add_argument("--max_seq_length",

default=128,

type=int,

help="The maximum total input sequence length after WordPiece tokenization. \n"

"Sequences longer than this will be truncated, and sequences shorter \n"

"than this will be padded.")

parser.add_argument("--do_lower_case",

default=False,

action='store_true',

help="Set this flag if you are using an uncased model.")

parser.add_argument("--train_batch_size",

default=32,

type=int,

help="Total batch size for training.")

parser.add_argument("--eval_batch_size",

default=32,

type=int,

help="Total batch size for eval.")

parser.add_argument("--learning_rate",

default=5e-5,

type=float,

help="The initial learning rate for Adam.")

parser.add_argument("--num_train_epochs",

default=8,

type=int,

help="Total number of training epochs to perform.")

# parser.add_argument("--warmup_proportion",

# default=0.1,

# type=float,

# help="Proportion of training to perform linear learning rate warmup for. "

# "E.g., 0.1 = 10%% of training.")

parser.add_argument("--no_cuda",

default=False,

action='store_true',

help="Whether not to use CUDA when available")

parser.add_argument("--local_rank",

type=int,

default=-1,

help="local_rank for distributed training on gpus")

parser.add_argument('--seed',

type=int,

default=42,

help="random seed for initialization")

parser.add_argument('--gradient_accumulation_steps',

type=int,

default=1,

help="Number of updates steps to accumulate before performing a backward/update pass.")

parser.add_argument('--fp16',

default=False,

action='store_true',

help="Whether to use 16-bit float precision instead of 32-bit")

parser.add_argument('--loss_scale',

type=float, default=0,

help="Loss scaling to improve fp16 numeric stability. Only used when fp16 set to True.\n"

"0 (default value): dynamic loss scaling.\n"

"Positive power of 2: static loss scaling value.\n")

main(parser.parse_args())