Upload FinetuneModelTrainerForRunningInSpaces.py

FinetuneModelTrainerForRunningInSpaces.py

@@ -0,0 +1,68 @@
+import torch
+import transformers
+import random
+
+# Define the model configuration and tokenizer
+config = transformers.AutoConfig.from_pretrained("bert-base-uncased")
+tokenizer = transformers.AutoTokenizer.from_pretrained("bert-base-uncased")
+
+# Load the pretrained model
+model = transformers.AutoModelForSequenceClassification.from_pretrained("bert-base-uncased", config=config)
+
+# Set the hyperparameters for fine-tuning
+num_epochs = 3
+batch_size = 32
+learning_rate = 2e-5
+
+# Create the model optimizer
+optimizer = transformers.AdamW(model.parameters(), lr=learning_rate)
+
+# Define the data collator
+def collate_fn(data):
+    input_ids = torch.tensor([tokenizer(text, padding="max_length", truncation=True)["input_ids"] for text in data["text"]])
+    attention_mask = torch.tensor([tokenizer(text, padding="max_length", truncation=True)["attention_mask"] for text in data["text"]])
+    labels = torch.tensor(data["label"])
+    return {"input_ids": input_ids, "attention_mask": attention_mask, "labels": labels}
+
+# Split the training data into training and validation sets
+def split_data(data, validation_size=0.2):
+    validation_indices = random.sample(range(len(data)), int(len(data) * validation_size))
+    train_data = []
+    val_data = []
+    for i, item in enumerate(data):
+        if i in validation_indices:
+            val_data.append(item)
+        else:
+            train_data.append(item)
+    return train_data, val_data
+
+# Split the training data
+train_data, val_data = split_data(train_data, validation_size=0.2)
+
+# Finetune the model
+for epoch in range(num_epochs):
+    # Create the training data loader
+    train_loader = transformers.DataLoader(train_data, batch_size=batch_size, shuffle=True, collate_fn=collate_fn)
+
+    # Train the model for one epoch
+    model.train()
+    for batch in train_loader:
+        optimizer.zero_grad()
+        outputs = model(**batch)
+        loss = outputs.loss
+        loss.backward()
+        optimizer.step()
+        
+
+    # Evaluate the model on the validation dataset
+    model.eval()
+    with torch.no_grad():
+        val_loss = 0.0
+        for batch in val_loader:
+            outputs = model(**batch)
+            val_loss += outputs.loss.item()
+
+    print("Epoch {}: Train Loss: {:.4f} Val Loss: {:.4f}".format(epoch + 1, train_loss / len(train_loader), val_loss / len(val_loader)))
+
+# Save the fine-tuned model
+model.save_pretrained("finetuned_model")