How to use the transformers.BertConfig.from_pretrained function in transformers

def test_model_from_pretrained(self):
        logging.basicConfig(level=logging.INFO)
        for model_name in list(BERT_PRETRAINED_MODEL_ARCHIVE_MAP.keys())[:1]:
            config = BertConfig.from_pretrained(model_name)
            self.assertIsNotNone(config)
            self.assertIsInstance(config, PretrainedConfig)

            model = BertModel.from_pretrained(model_name)
            model, loading_info = BertModel.from_pretrained(model_name, output_loading_info=True)
            self.assertIsNotNone(model)
            self.assertIsInstance(model, PreTrainedModel)
            for value in loading_info.values():
                self.assertEqual(len(value), 0)

            config = BertConfig.from_pretrained(model_name, output_attentions=True, output_hidden_states=True)
            model = BertModel.from_pretrained(model_name, output_attentions=True, output_hidden_states=True)
            self.assertEqual(model.config.output_attentions, True)
            self.assertEqual(model.config.output_hidden_states, True)
            self.assertEqual(model.config, config)

def __init__(self, model_name: str) -> None:
        super().__init__()
        config = BertConfig.from_pretrained(model_name)
        self.input_dim = config.hidden_size
        self.output_dim = config.vocab_size
        # TODO(mattg): It's possible that we could use some kind of cache like we have in
        # allennlp.modules.token_embedders.bert_token_embedder.PretrainedBertModel.  That way, we
        # would only load the BERT weights once.  Though, it's not clear how to do that here, as we
        # need to load `BertForMaskedLM`, not just `BertModel`...
        bert_model = BertForMaskedLM.from_pretrained(model_name)
        self.bert_lm_head = bert_model.cls

def _prepare_model(self, freeze, task_name='default'):
        """Prepare a model to be trained

        Arguments:
            freeze {bool} -- Whether to freeze the BERT layers.

        Returns:
            [BertForMultipleChoice] -- BertForMultipleChoice model to train
        """
        config = BertConfig.from_pretrained(
            self.bert_model,
            num_labels=self.num_choices,
            finetuning_task=task_name,
            cache_dir=os.path.join(
                str(PYTORCH_PRETRAINED_BERT_CACHE),
                'distributed_{}'.format(self.local_rank)),
        )

        model = BertForMultipleChoice.from_pretrained(
            self.bert_model,
            from_tf=bool(".ckpt" in self.bert_model),
            config=config,
            cache_dir=os.path.join(
                str(PYTORCH_PRETRAINED_BERT_CACHE),
                'distributed_{}'.format(self.local_rank)),
        )

"Output directory ({}) already exists and is not empty. Use --do_overwrite_output_dir to overwrite.".format(
                args.output_dir
            )
        )

    # Set up training device
    if args.to_cpu or not torch.cuda.is_available():
        args.device = torch.device("cpu")
        args.n_gpu = 0
    else:
        args.device = torch.device("cuda")
        args.n_gpu = torch.cuda.device_count()

    # Load pretrained model and tokenizer. The decoder's weights are randomly initialized.
    tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path)
    config = BertConfig.from_pretrained(args.model_name_or_path)
    decoder_model = BertForMaskedLM(config)
    model = Model2Model.from_pretrained(
        args.model_name_or_path, decoder_model=decoder_model
    )

    # Setup logging
    logging.basicConfig(
        format="%(asctime)s - %(levelname)s - %(name)s -   %(message)s",
        datefmt="%m/%d/%Y %H:%M:%S",
        level=logging.INFO,
    )
    logger.warning(
        "Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s",
        0,
        args.device,
        args.n_gpu,

def __init__(self, model_dir, data_dir, model_name="caip_test_model"):
        model_name = model_dir + model_name
        args = pickle.load(open(model_name + "_args.pk", "rb"))

        args.data_dir = data_dir

        self.tokenizer = AutoTokenizer.from_pretrained(args.pretrained_encoder_name)
        full_tree, tree_i2w = json.load(open(model_name + "_tree.json"))
        self.dataset = CAIPDataset(
            self.tokenizer, args, prefix="", full_tree_voc=(full_tree, tree_i2w)
        )

        enc_model = AutoModel.from_pretrained(args.pretrained_encoder_name)
        bert_config = BertConfig.from_pretrained("bert-base-uncased")
        bert_config.is_decoder = True
        bert_config.vocab_size = len(tree_i2w) + 8

        bert_config.num_hidden_layers = args.num_decoder_layers
        dec_with_loss = DecoderWithLoss(bert_config, args, self.tokenizer)
        self.encoder_decoder = EncoderDecoderWithLoss(enc_model, dec_with_loss, args)
        map_location = None if torch.cuda.is_available() else torch.device("cpu")
        self.encoder_decoder.load_state_dict(
            torch.load(model_name + ".pth", map_location=map_location), strict=False
        )
        self.encoder_decoder = (
            self.encoder_decoder.cuda()
            if torch.cuda.is_available()
            else self.encoder_decoder.cpu()
        )
        self.encoder_decoder.eval()

def __init__(self):
        super(Bert, self).__init__()
        config = BertConfig.from_pretrained("bert-base-uncased")
        self.model = BertModel(config)

def model_fn():
        config = BertConfig.from_pretrained("bert-base-cased")
        config.num_labels = 3
        model = TFBertForSequenceClassification.from_pretrained("bert-base-cased", config=config)
        optimizer = tf.keras.optimizers.Adam()
        model.optimizer = optimizer
        return model