Recently, the Hugging Face library has been widely used in both natural language processing (NLP) and computer vision (CV) fields within artificial intelligence and deep learning. In this article, we will explain how to process image datasets and train models using the Hugging Face Transformers library, and we will explore this in detail with example code.<\/p>\n
Hugging Face is a library that provides various pre-trained models related to natural language processing, making it easy to use models like BERT, GPT-2, and T5. However, recently, image processing models such as Vision Transformer (ViT) and CLIP have been added, which demonstrate strong performance in computer vision tasks as well.<\/p>\n
Before using the Hugging Face Transformers library, you must first install the required packages. You can easily install them with the following code.<\/p>\n
pip install transformers torchvision torch<\/code><\/pre>\n3. Sample Image Dataset<\/h2>\n
In this tutorial, we will use the CIFAR-10 dataset as sample data. CIFAR-10 consists of 60,000 32×32 color images distributed across 10 classes (airplane, automobile, bird, cat, deer, dog, frog, horse, ship, truck). This dataset is very suitable for image classification problems.<\/p>\n
3.1 Loading the Dataset<\/h3>\n
We will use the torchvision library in Python to load the CIFAR-10 dataset and split it into training and validation sets.<\/p>\n
import torchvision\nimport torchvision.transforms as transforms\n\n# Set data transformations\ntransform = transforms.Compose([\n transforms.ToTensor(),\n transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n])\n\n# Load training and validation datasets\ntrainset = torchvision.datasets.CIFAR10(root='.\/data', train=True, download=True, transform=transform)\ntrainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True, num_workers=2)\n\ntestset = torchvision.datasets.CIFAR10(root='.\/data', train=False, download=True, transform=transform)\ntestloader = torch.utils.data.DataLoader(testset, batch_size=4, shuffle=False, num_workers=2)\n<\/code><\/pre>\n3.2 Data Preprocessing<\/h3>\n
The loaded dataset needs to undergo a transformation process where the image data is converted to tensor form and normalized. In the code above, the ToTensor() method is used to convert images to tensors, and the Normalize() method performs normalization based on the mean and standard deviation.<\/p>\n
4. Building the Vision Transformer (ViT) Model<\/h2>\n
Now we will build the ViT model to classify images from the CIFAR-10 dataset. The model definition can be easily implemented using the Hugging Face Transformers library.<\/p>\n
from transformers import ViTForImageClassification, ViTFeatureExtractor\n\n# Initialize ViT model and feature extractor\nfeature_extractor = ViTFeatureExtractor.from_pretrained('google\/vit-base-patch16-224')\nmodel = ViTForImageClassification.from_pretrained('google\/vit-base-patch16-224', num_labels=10)\n<\/code><\/pre>\nThe above code initializes the Vision Transformer model, where the `num_labels` parameter is used to set the number of classes. Here, we set it to 10, as we have 10 classes.<\/p>\n
5. Model Training<\/h2>\n
To train the model, we need to define the loss function and optimization algorithm. In this case, we will use the CrossEntropyLoss loss function and the Adam optimizer.<\/p>\n
import torch.optim as optim\n\n# Define loss function and optimization algorithm\ncriterion = torch.nn.CrossEntropyLoss()\noptimizer = optim.Adam(model.parameters(), lr=0.001)\n\n# Set device for model training\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\nmodel.to(device)\n\n# Train the model\nfor epoch in range(10): # Train for 10 epochs\n running_loss = 0.0\n for i, data in enumerate(trainloader, 0):\n inputs, labels = data\n inputs, labels = inputs.to(device), labels.to(device)\n\n # Zero the gradients\n optimizer.zero_grad()\n\n # Forward + backward + optimize\n outputs = model(inputs).logits\n loss = criterion(outputs, labels)\n loss.backward()\n optimizer.step()\n\n running_loss += loss.item()\n if i % 2000 == 1999: # Print every 2000 mini-batches\n print(f\"[{epoch + 1}, {i + 1}] loss: {running_loss \/ 2000:.3f}\")\n running_loss = 0.0\n<\/code><\/pre>\nThe above code represents the process of training the model according to the number of epochs and mini-batches. It calculates the loss for each batch and updates the weights through backpropagation.<\/p>\n
6. Model Evaluation<\/h2>\n
To evaluate the trained model, we will use the test dataset. The method for evaluating the model’s accuracy is as follows.<\/p>\n
correct = 0\ntotal = 0\n\nwith torch.no_grad():\n for data in testloader:\n images, labels = data\n images, labels = images.to(device), labels.to(device)\n outputs = model(images).logits\n _, predicted = torch.max(outputs.data, 1)\n total += labels.size(0)\n correct += (predicted == labels).sum().item()\n\nprint(f'Accuracy of the network on the 10000 test images: {100 * correct \/ total:.2f}%')\n<\/code><\/pre>\nThe above code calculates the model’s accuracy on the test dataset. It compares the predicted values against the actual labels for each image to compute the accuracy.<\/p>\n
7. Conclusion<\/h2>\n
In this article, we explored how to process CIFAR-10 data using the Hugging Face Transformers library and how to build a Vision Transformer model to classify images. Utilizing the Hugging Face library allows for easily constructing complex models and optimizing performance with various datasets. We encourage you to continue exploring deep learning use cases with diverse models and datasets in the future.<\/p>\n
If you have any questions or need additional information, please feel free to leave a comment.<\/p>\n","protected":false},"excerpt":{"rendered":"