Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Senior[[:space:]]Project[[:space:]]-[[:space:]]Final[[:space:]]Report[[:space:]]Example.pdf filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,12 +1,6 @@
 ---
-title: Echo Chatbot
-emoji: 📉
-colorFrom: gray
-colorTo: blue
+title: echo-chatbot
+app_file: app.py
 sdk: gradio
 sdk_version: 4.16.0
-app_file: app.py
-pinned: false
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

Senior Project - Final Report Example.pdf

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

app.py

@@ -0,0 +1,6 @@
+import gradio as gr
+
+def slow_echo(message, history):
+    return message
+
+demo = gr.ChatInterface(slow_echo).queue().launch()

chapter1_2.py

@@ -0,0 +1,201 @@
+# https://huggingface.co/MoritzLaurer/DeBERTa-v3-base-mnli-fever-anli
+# from transformers import pipeline
+# classifier = pipeline("zero-shot-classification", model="MoritzLaurer/DeBERTa-v3-base-mnli-fever-anli")
+# sequence_to_classify = "Angela Merkel is a politician in Germany and leader of the CDU"
+# candidate_labels = ["politics", "economy", "entertainment", "environment"]
+# output = classifier(sequence_to_classify, candidate_labels, multi_label=False)
+# print(output)
+
+# from transformers import pipeline
+
+# generator = pipeline("text-generation", model="distilgpt2")
+# output = generator("In this course, we will teach you how to")
+# print(output)
+
+# https://huggingface.co/bigscience/bloom-560m
+# from transformers import AutoTokenizer, AutoModelForCausalLM
+# import transformers
+# import torch
+
+# model = "bigscience/bloom-560m"
+
+# tokenizer = AutoTokenizer.from_pretrained(model)
+# pipeline = transformers.pipeline(
+#     "text-generation",
+#     model=model,
+#     tokenizer=tokenizer,
+#     torch_dtype=torch.bfloat16,
+#     trust_remote_code=True,
+#     device_map="auto",
+# )
+# sequences = pipeline(
+#    "Girafatron is obsessed with giraffes, the most glorious animal on the face of this Earth. Giraftron believes all other animals are irrelevant when compared to the glorious majesty of the giraffe.\nDaniel: Hello, Girafatron!\nGirafatron:",
+#     max_length=200,
+#     do_sample=True,
+#     top_k=10,
+#     num_return_sequences=1,
+#     eos_token_id=tokenizer.eos_token_id,
+# )
+# for seq in sequences:
+#     print(f"Result: {seq['generated_text']}")
+
+# https://huggingface.co/bert-base-uncased
+# from transformers import pipeline
+# unmasker = pipeline('fill-mask', model='bert-base-multilingual-cased')
+# output = unmasker("tu es [MASK] homme?")
+
+
+# named entity recognition
+# from transformers import pipeline
+
+# ner = pipeline("ner", grouped_entities=True)
+# output = ner("My name is Sylvain and I work at Hugging Face in Brooklyn.")
+
+# https://huggingface.co/facebook/bart-large-cnn
+from transformers import pipeline
+
+# summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
+# output = summarizer(
+#     """
+#     America has changed dramatically during recent years. Not only has the number of 
+#     graduates in traditional engineering disciplines such as mechanical, civil, 
+#     electrical, chemical, and aeronautical engineering declined, but in most of 
+#     the premier American universities engineering curricula now concentrate on 
+#     and encourage largely the study of engineering science. As a result, there 
+#     are declining offerings in engineering subjects dealing with infrastructure, 
+#     the environment, and related issues, and greater concentration on high 
+#     technology subjects, largely supporting increasingly complex scientific 
+#     developments. While the latter is important, it should not be at the expense 
+#     of more traditional engineering.
+
+#     Rapidly developing economies such as China and India, as well as other 
+#     industrial countries in Europe and Asia, continue to encourage and advance 
+#     the teaching of engineering. Both China and India, respectively, graduate 
+#     six and eight times as many traditional engineers as does the United States. 
+#     Other industrial countries at minimum maintain their output, while America 
+#     suffers an increasingly serious decline in the number of engineering graduates 
+#     and a lack of well-educated engineers.
+# """
+# )
+
+# from transformers import pipeline
+
+# translator = pipeline("translation", model="Helsinki-NLP/opus-mt-zh-en")
+# output = translator("屌")
+
+# print(output)
+
+# from transformers import AutoTokenizer
+
+# tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
+
+# sequence = "Using a Transformer network is simple"
+# tokens = tokenizer.tokenize(sequence)
+# print(tokens)
+# ids = tokenizer.convert_tokens_to_ids(tokens)
+# print(ids)
+# decoded_string = tokenizer.decode(ids)
+# print(decoded_string)
+# print("----------------------")
+
+# sequence = "Using a Transform network are simple"
+# tokens = tokenizer.tokenize(sequence)
+# print(tokens)
+# ids = tokenizer.convert_tokens_to_ids(tokens)
+# print(ids)
+# decoded_string = tokenizer.decode(ids)
+# print(decoded_string)
+
+# import torch
+# from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+# checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
+# tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+# model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
+
+# sequence = "I’ve been waiting for a HuggingFace course my whole life."
+# tokens = tokenizer.tokenize(sequence)
+# print(tokens)
+# sequence1_ids = tokenizer.convert_tokens_to_ids(tokens)
+# print(sequence1_ids)
+
+# sequence = "I hate this so much!"
+# tokens = tokenizer.tokenize(sequence)
+# print(tokens)
+# sequence2_ids = tokenizer.convert_tokens_to_ids(tokens)
+# print(sequence2_ids)
+
+# sequence1_ids = [[200, 200, 200]]
+# sequence2_ids = [[200, 200]]
+# batched_ids = [
+#     [1045, 1521, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012],
+#     [1045, 5223, 2023, 2061, 2172, 999, tokenizer.pad_token_id, tokenizer.pad_token_id, tokenizer.pad_token_id, tokenizer.pad_token_id, tokenizer.pad_token_id, tokenizer.pad_token_id, tokenizer.pad_token_id, tokenizer.pad_token_id],
+# ]
+
+# attention_mask = [
+#     [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+#     [1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+# ]
+
+# outputs = model(torch.tensor(batched_ids), attention_mask=torch.tensor(attention_mask))
+# print(outputs.logits)
+
+# from transformers import AutoTokenizer
+
+# checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
+# tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+
+# sequence = "I've been waiting for a HuggingFace course my whole life."
+
+# model_inputs = tokenizer(sequence)
+
+# print(model_inputs)
+
+# sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"]
+# Will pad the sequences up to the maximum sequence length
+# model_inputs = tokenizer(sequences, padding="longest")
+# print(model_inputs)
+# print("-------------------------")
+
+# Will pad the sequences up to the specified max length
+# model_inputs = tokenizer(sequences, padding="max_length", max_length=8)
+# print(model_inputs)
+
+# from transformers import AutoTokenizer
+# checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
+# tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+
+# sequence = "I've been waiting for a HuggingFace course my whole life."
+
+# model_inputs = tokenizer(sequence)
+# print("model_inputs = tokenizer(sequence)")
+# print(model_inputs)
+# print(model_inputs["input_ids"])
+
+# tokens = tokenizer.tokenize(sequence)
+# print("tokens = tokenizer.tokenize(sequence)")
+# print(tokens)
+# ids = tokenizer.convert_tokens_to_ids(tokens)
+# print(sequence)
+# print(ids)
+
+# import torch
+# from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+# checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
+# tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+# model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
+# sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"]
+
+# tokens = tokenizer(sequences, padding=True, truncation=True, return_tensors="pt")
+# output = model(**tokens)
+# print(output)
+
+from transformers import AutoTokenizer, AutoModel
+
+tokenizer = AutoTokenizer.from_pretrained("gpt2")
+model = AutoModel.from_pretrained("gpt2")
+
+encoded = tokenizer("Hey!", return_tensors="pt")
+result = model(**encoded)
+print(result)

chapter3.py

@@ -0,0 +1,247 @@
+# import torch
+# from transformers import AdamW, AutoTokenizer, AutoModelForSequenceClassification
+
+# # Same as before
+# checkpoint = "bert-base-uncased"
+# tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+# model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
+# sequences = [
+#     "I've been waiting for a HuggingFace course my whole life.",
+#     "This course is amazing!",
+# ]
+# batch = tokenizer(sequences, padding=True, truncation=True, return_tensors="pt")
+
+# # This is new
+# batch["labels"] = torch.tensor([1, 1])
+
+# optimizer = AdamW(model.parameters())
+# loss = model(**batch).loss
+# loss.backward()
+# optimizer.step()
+
+from datasets import load_dataset
+
+# raw_datasets = load_dataset("glue", "sst2")
+# raw_datasets
+# raw_train_dataset = raw_datasets["train"]
+# output = raw_train_dataset[0]['sentence']
+# print(output)
+
+# raw_train_dataset = raw_datasets["validation"]
+# output = raw_train_dataset[87]
+
+# print(raw_train_dataset.features)
+
+# from transformers import AutoTokenizer
+
+# checkpoint = "bert-base-uncased"
+# tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+# print(tokenizer(output))
+# inputs = tokenizer(output)
+# print(tokenizer.convert_ids_to_tokens(inputs["input_ids"]))
+
+# inputs = tokenizer("This is the first sentence.")
+# print(inputs)
+# print(tokenizer.convert_ids_to_tokens(inputs["input_ids"]))
+# # tokenized_sentences_1 = tokenizer(raw_datasets["train"]["sentence1"])
+# # tokenized_sentences_2 = tokenizer(raw_datasets["train"]["sentence2"])
+
+# # inputs = tokenizer("This is the first sentence.", "This is the second one.")
+# # inputs = tokenizer.convert_ids_to_tokens(inputs["input_ids"])
+# # print(inputs)
+
+# def tokenize_function(example):
+#     return tokenizer(example["sentence"], truncation=True)
+
+# tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)
+# print(tokenized_datasets)
+
+# from transformers import DataCollatorWithPadding
+
+# data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
+# samples = tokenized_datasets["train"][:8]
+# samples = {k: v for k, v in samples.items() if k not in ["idx", "sentence1", "sentence2"]}
+
+# print([len(x) for x in samples["input_ids"]])
+
+# batch = data_collator(samples)
+# print(batch)
+# print({k: v.shape for k, v in batch.items()})
+
+# # Try it yourself
+from datasets import load_dataset
+
+raw_datasets = load_dataset("glue", "sst2")
+raw_train_dataset = raw_datasets["train"]
+output = raw_train_dataset[0]['sentence']
+# print(output)
+
+from transformers import AutoTokenizer
+
+checkpoint = "bert-base-uncased"
+tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+# print(tokenizer(output))
+inputs = tokenizer(output)
+# print(tokenizer.convert_ids_to_tokens(inputs["input_ids"]))
+
+tokenized_dataset = tokenizer(
+    output,
+    padding=True,
+    truncation=True,
+)
+
+def tokenize_function(example):
+    return tokenizer(example["sentence"], truncation=True)
+
+tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)
+# print(tokenized_datasets)
+
+
+# from datasets import load_dataset
+# from transformers import AutoTokenizer, DataCollatorWithPadding
+
+# raw_datasets = load_dataset("glue", "mrpc")
+# checkpoint = "bert-base-uncased"
+# tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+
+
+# def tokenize_function(example):
+#     return tokenizer(example["sentence1"], example["sentence2"], truncation=True)
+
+
+# tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)
+# data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
+
+# from transformers import TrainingArguments
+
+# training_args = TrainingArguments("test-trainer")
+
+# from transformers import AutoModelForSequenceClassification
+
+# model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
+
+# from transformers import Trainer
+
+# trainer = Trainer(
+#     model,
+#     training_args,
+#     train_dataset=tokenized_datasets["train"],
+#     eval_dataset=tokenized_datasets["validation"],
+#     data_collator=data_collator,
+#     tokenizer=tokenizer,
+# )
+# predictions = trainer.predict(tokenized_datasets["validation"])
+# print(predictions.predictions.shape, predictions.label_ids.shape)
+
+# import numpy as np
+
+# preds = np.argmax(predictions.predictions, axis=-1)
+
+# import evaluate
+
+# metric = evaluate.load("glue", "mrpc")
+# metric.compute(predictions=preds, references=predictions.label_ids)
+
+# def compute_metrics(eval_preds):
+#     metric = evaluate.load("glue", "mrpc")
+#     logits, labels = eval_preds
+#     predictions = np.argmax(logits, axis=-1)
+#     return metric.compute(predictions=predictions, references=labels)
+
+# training_args = TrainingArguments("test-trainer", evaluation_strategy="epoch")
+# model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
+
+# trainer = Trainer(
+#     model,
+#     training_args,
+#     train_dataset=tokenized_datasets["train"],
+#     eval_dataset=tokenized_datasets["validation"],
+#     data_collator=data_collator,
+#     tokenizer=tokenizer,
+#     compute_metrics=compute_metrics,
+# )
+# trainer.train()
+from transformers import AutoTokenizer, DataCollatorWithPadding
+
+data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
+tokenized_datasets = tokenized_datasets.remove_columns(["sentence", "idx"])
+tokenized_datasets = tokenized_datasets.rename_column("label", "labels")
+tokenized_datasets.set_format("torch")
+tokenized_datasets["train"].column_names
+
+from torch.utils.data import DataLoader
+
+train_dataloader = DataLoader(
+    tokenized_datasets["train"], shuffle=True, batch_size=8, collate_fn=data_collator
+)
+eval_dataloader = DataLoader(
+    tokenized_datasets["validation"], batch_size=8, collate_fn=data_collator
+)
+for batch in train_dataloader:
+    break
+output = {k: v.shape for k, v in batch.items()}
+# print(output)
+
+from transformers import AutoModelForSequenceClassification
+
+model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
+
+outputs = model(**batch)
+# print(outputs.loss, outputs.logits.shape)
+
+from transformers import AdamW
+
+optimizer = AdamW(model.parameters(), lr=5e-5)
+
+from transformers import get_scheduler
+
+num_epochs = 3
+num_training_steps = num_epochs * len(train_dataloader)
+lr_scheduler = get_scheduler(
+    "linear",
+    optimizer=optimizer,
+    num_warmup_steps=0,
+    num_training_steps=num_training_steps,
+)
+print(num_training_steps)
+
+# The training loop
+import torch
+
+device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+model.to(device)
+# print(device)
+
+
+from tqdm.auto import tqdm
+
+progress_bar = tqdm(range(num_training_steps))
+
+model.train()
+for epoch in range(num_epochs):
+    for batch in train_dataloader:
+        batch = {k: v.to(device) for k, v in batch.items()}
+        outputs = model(**batch)
+        loss = outputs.loss
+        loss.backward()
+
+        optimizer.step()
+        lr_scheduler.step()
+        optimizer.zero_grad()
+        progress_bar.update(1)
+
+# The evaluation loop
+import evaluate
+
+metric = evaluate.load("glue", "mrpc")
+model.eval()
+for batch in eval_dataloader:
+    batch = {k: v.to(device) for k, v in batch.items()}
+    with torch.no_grad():
+        outputs = model(**batch)
+
+    logits = outputs.logits
+    predictions = torch.argmax(logits, dim=-1)
+    metric.add_batch(predictions=predictions, references=batch["labels"])
+
+metric.compute()

chapter4.py

@@ -0,0 +1,4 @@
+from transformers import AutoTokenizer, AutoModelForMaskedLM
+
+tokenizer = AutoTokenizer.from_pretrained("camembert-base", force_download=True, resume_download=False)
+model = AutoModelForMaskedLM.from_pretrained("camembert-base")

chat.py

@@ -0,0 +1,66 @@
+import random
+
+def random_response(message, history):
+    return random.choice(["Yes", "No"])
+
+import time
+import gradio as gr
+
+def yes_man(message, history):
+    if message.endswith("?"):
+        return "Yes"
+    else:
+        return "Ask me anything!"
+
+def echo(message, history, system_prompt, tokens):
+    response = f"System prompt: {system_prompt}\n Message: {message}."
+    for i in range(min(len(response), int(tokens))):
+        time.sleep(0.05)
+        yield response[: i+1]
+
+# from langchain.chat_models import ChatOpenAI
+# from langchain.schema import AIMessage, HumanMessage
+# import openai
+# import gradio as gr
+# import os
+
+# os.environ["OPENAI_API_KEY"] = "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"  # Replace with your key
+
+# llm = ChatOpenAI(temperature=1.0, model='gpt-3.5-turbo-0613')
+
+# def predict(message, history):
+#     history_langchain_format = []
+#     for human, ai in history:
+#         history_langchain_format.append(HumanMessage(content=human))
+#         history_langchain_format.append(AIMessage(content=ai))
+#     history_langchain_format.append(HumanMessage(content=message))
+#     gpt_response = llm(history_langchain_format)
+#     return gpt_response.content
+
+# gr.ChatInterface(predict).launch()
+
+import openai
+import gradio as gr
+
+openai.api_key = "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"  # Replace with your key
+
+from langchain.chat_models import ChatOpenAI
+from langchain.schema import AIMessage, HumanMessage
+import openai
+import gradio as gr
+import os
+    
+os.environ["OPENAI_API_KEY"] = "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"
+
+llm = ChatOpenAI(temperature=1.0, model='gpt-3.5-turbo-0613')
+
+def predict(message, history):
+    history_langchain_format = []
+    for human, ai in history:
+        history_langchain_format.append(HumanMessage(content=human))
+        history_langchain_format.append(AIMessage(content=ai))
+    history_langchain_format.append(HumanMessage(content=message))
+    gpt_response = llm(history_langchain_format)
+    return gpt_response.content
+
+gr.ChatInterface(predict).launch()

gradio_cached_examples/16/log.csv

@@ -0,0 +1,4 @@
+component 0,flag,username,timestamp
+"[[""Hello"",""Ask me anything!""]]",,,2024-01-28 21:12:34.005450
+"[[""Want a fuck?"",""Yes""]]",,,2024-01-28 21:12:34.005450
+"[[""Why so fucking sexy?"",""Yes""]]",,,2024-01-28 21:12:34.021247

test-trainer/checkpoint-500/config.json

@@ -0,0 +1,27 @@
+{
+  "_name_or_path": "bert-base-uncased",
+  "architectures": [
+    "BertForSequenceClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "classifier_dropout": null,
+  "gradient_checkpointing": false,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "problem_type": "single_label_classification",
+  "torch_dtype": "float32",
+  "transformers_version": "4.37.1",
+  "type_vocab_size": 2,
+  "use_cache": true,
+  "vocab_size": 30522
+}

test-trainer/checkpoint-500/model.safetensors

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

test-trainer/checkpoint-500/optimizer.pt

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

test-trainer/checkpoint-500/rng_state.pth

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

test-trainer/checkpoint-500/scheduler.pt

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

test-trainer/checkpoint-500/special_tokens_map.json

@@ -0,0 +1,7 @@
+{
+  "cls_token": "[CLS]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}

test-trainer/checkpoint-500/tokenizer_config.json

@@ -0,0 +1,55 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "100": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "101": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "102": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "103": {
+      "content": "[MASK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "[CLS]",
+  "do_lower_case": true,
+  "mask_token": "[MASK]",
+  "model_max_length": 512,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "unk_token": "[UNK]"
+}

test-trainer/checkpoint-500/trainer_state.json

@@ -0,0 +1,27 @@
+{
+  "best_metric": null,
+  "best_model_checkpoint": null,
+  "epoch": 1.0893246187363834,
+  "eval_steps": 500,
+  "global_step": 500,
+  "is_hyper_param_search": false,
+  "is_local_process_zero": true,
+  "is_world_process_zero": true,
+  "log_history": [
+    {
+      "epoch": 1.09,
+      "learning_rate": 3.184458968772695e-05,
+      "loss": 0.4912,
+      "step": 500
+    }
+  ],
+  "logging_steps": 500,
+  "max_steps": 1377,
+  "num_input_tokens_seen": 0,
+  "num_train_epochs": 3,
+  "save_steps": 500,
+  "total_flos": 147381246548880.0,
+  "train_batch_size": 8,
+  "trial_name": null,
+  "trial_params": null
+}

test-trainer/checkpoint-500/training_args.bin

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

test-trainer/runs/Jan27_22-08-26_DESKTOP-KTM59NT/events.out.tfevents.1706382507.DESKTOP-KTM59NT.3612.0

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

test-trainer/runs/Jan28_06-39-34_DESKTOP-KTM59NT/events.out.tfevents.1706413175.DESKTOP-KTM59NT.17992.0

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