File size: 2,231 Bytes
4abf447 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 |
import torch
import torchvision
from torchvision.models import resnet50
from torchvision.transforms import transforms
from torch.utils.data import DataLoader, Dataset
# Define the dataset class
class RobloxDataset(Dataset):
def __init__(self, root_dir, transform=None):
self.root_dir = root_dir
self.transform = transform
def __len__(self):
return 200 # Number of images in the dataset, replace with your own to train with your own images.
def __getitem__(self, idx):
img_path = f'{self.root_dir}/human_{str(idx+1).zfill(2)}.png'
image = Image.open(img_path).convert('RGB')
if self.transform:
image = self.transform(image)
return image
data_transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
dataset = RobloxDataset('/content/dataset', transform=data_transform)
data_loader = DataLoader(dataset, batch_size=1, shuffle=True)
model = resnet50(pretrained=True)
model.fc = torch.nn.Linear(in_features=2048, out_features=1) # Adjust the number of output classes if needed
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
criterion = torch.nn.BCEWithLogitsLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
# Train the model
num_epochs = 100 # Adjust the number of training epochs (more epochs = more training time but with more accuracy and less loss).
""" Training the model with more epochs
Pros:
- more accuracy
- less loss (it means the model is improving)
Con:
- more training time
"""
for epoch in range(num_epochs):
for images in data_loader:
images = images.to(device)
labels = torch.ones((images.size(0), 1)).to(device) # Assuming all images belong to the same class
outputs = model(images)
loss = criterion(outputs, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item()}')
# Save the trained model
torch.save(model.state_dict(), '/content/zero_shot_classification_model.pth') |