算法调优赛：
初赛：甲骨文字识别 任务描述：甲骨文是我国迄今为止发现的最古老的成熟文字体系，由于其书写载体包括龟腹 甲、龟背甲、牛肩胛骨等，人们将它命名为“甲骨文”。甲骨文记录了中国古代文明、中国文 化以及古代人类的思维思想。通过甲骨文，我们可以了解到中国古代的历史事件和社会生活。 在这个任务中，你需要构建深度学习模型，对不同的甲骨文图片进行分类。 评分标准：最终得分=准确率*100
决赛：遥感图像分类 任务描述：遥感图像分类在地理信息系统、环境监测和城市规划等领域具有广泛的应用。随 着遥感技术的不断发展和遥感图像数据的快速增长，如何高效准确地对遥感图像进行分类成 为一个重要的研究方向。在这个任务中，你需要构建深度神经网络，对遥感图像进行分类。 评分标准：最终得分=准确率*100
初赛和国赛的数据集结构都是一样的，就是纯cv的分类，大家都是99+，98+，就是看谁抖的高了
冠军佬用的effnet，github主页cpboost (pengcheng)
提供另一位国一大佬的方案，里面有数据集fyq66/fengyvqing: 遥感图像的分类（2024睿抗机器人开发者大赛全国总决赛国一项目）
本人使用resnet获得亚军，代码暂不开源，等保研之后会开源
train.py
from torchvision.datasets import ImageFolder
from torch.utils.data import Dataset, DataLoader
import torchvision.transforms as transforms
import torch.nn as nn
import numpy as np
import pandas as pd
import torch.optim as optim
from PIL import Image
from tqdm import tqdm
import torch.nn.functional as F
import torch
import random
from torch.optim import lr_scheduler
from torch.autograd import Variable
from torch.utils.data import Dataset, DataLoader
import timm
from timm.scheduler.cosine_lr import CosineLRScheduler
import os
os.environ["HF_ENDPOINT"] = "https://hf-mirror.com"
train_path = './train'
# test_path = './train'
seed = 3074
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
np.random.seed(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
class FixedRotation(object):
def __init__(self, angles):
self.angles = angles
def __call__(self, img):
return fixed_rotate(img, self.angles)
def fixed_rotate(img, angles):
angles = list(angles)
angles_num = len(angles)
index = random.randint(0, angles_num - 1)
return img.rotate(angles[index])
train_transform = transforms.Compose([
# transforms.RandomRotation(15),
transforms.Resize([384, 384]),
# transforms.RandomVerticalFlip(),
FixedRotation([0, 90, 180, -90]),
#transforms.RandomRotation(90),
transforms.ToTensor(),
transforms.Normalize((0.3705, 0.3828, 0.3545), (0.1685, 0.1590, 0.1536))
])
val_transform = transforms.Compose([
transforms.Resize([256, 256]),
transforms.ToTensor(),
transforms.Normalize((0.3705, 0.3828, 0.3545), (0.1685, 0.1590, 0.1536))
])
train_transform2 = transforms.Compose([
transforms.AutoAugment(policy=transforms.AutoAugmentPolicy.IMAGENET),
transforms.Resize([256,256 ]),
transforms.ToTensor(),
transforms.Normalize((0.3705, 0.3828, 0.3545), (0.1685, 0.1590, 0.1536)),
])
train_dataset=ImageFolder(train_path,transform=train_transform2)
trainloader = torch.utils.data.DataLoader(train_dataset, batch_size=64,shuffle=True, num_workers=0)
# test_dataset=ImageFolder(test_path,transform=val_transform)
# testloader = torch.utils.data.DataLoader(test_dataset, batch_size=64,shuffle=None, num_workers=0)
model_name = "mobilevit_s"
epoch_num=10
net=timm.create_model(model_name,pretrained=True,num_classes=5).cuda()
# weight = torch.load('./efficientnet_b0lab_8.pth')
# net.load_state_dict(weight['model_state_dict'])
criterion=nn.CrossEntropyLoss()
# weight_decay = 1e-4 # L2 正则化系数
optimizer = torch.optim.Adam(net.parameters(), lr=0.001,weight_decay=1e-4)
#lr_scheduler = CosineLRScheduler(optimizer, t_initial=0.02, lr_min=0.000004)
lr_scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=4, gamma=0.1)
PATH = './'+model_name #这里也需要注意，你需要先新建一个dir文件夹，一会在这个文件下存放权重
pre_acc = 0
def get_cur_lr(optimizer):
for param_group in optimizer.param_groups:
return param_group['lr']
def validate(model, dataloader, criterion):
model.eval()
val_loss = 0.0
correct = 0
total = 0
with torch.no_grad():
for inputs, labels in dataloader:
inputs = inputs.cuda()
labels = labels.cuda()
outputs = model(inputs)
loss = criterion(outputs, labels)
val_loss += loss.item() * inputs.size(0)
correct += (outputs.argmax(dim=1) == labels).sum().item()
total += labels.size(0)
val_loss /= total
val_acc = 100.0 * correct / total
return val_loss, val_acc
best_val_acc=0
if __name__ == '__main__':
correct = 0
total = 0
for epoch in range(epoch_num):
print("========== epoch: [{}/{}] ==========".format(epoch + 1, epoch_num))
for i, (inputs, labels) in tqdm(enumerate(trainloader)):
inputs = inputs.cuda()
labels = labels.cuda()
outputs = net(inputs)
loss = criterion(outputs, labels)
correct += (outputs.argmax(dim=1) == labels).sum().item()
total += labels.size(0)
train_acc = 100.0 * correct / total
optimizer.zero_grad()
loss.backward()
optimizer.step()
if i % 10 == 0:
print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f} train acc: {:.6f} lr : {:.6f}'.format(epoch+1, i * len(inputs),
len(trainloader.dataset),100. * i / len(trainloader),loss.item(),train_acc,get_cur_lr(optimizer)))
if epoch % 1 ==0:
torch.save({'epoch': epoch,
'model_state_dict': net.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'loss': loss
},'./nfnet/'+PATH + "_"+str(epoch)+".pth")
# print('===================test============================')
# val_loss, val_acc = validate(net, testloader, criterion)
# print(f'Validation Loss: {val_loss:.6f}, Validation Accuracy: {val_acc:.6f}')
# Save the model if it has the best accuracy so far
# if val_acc > best_val_acc:
# best_val_acc = val_acc
# torch.save({'epoch': epoch,
# 'model_state_dict': net.state_dict(),
# 'optimizer_state_dict': optimizer.state_dict(),
# }, './weights2/'+PATH + "_best.pth")
# Save the model checkpoint
lr_scheduler.step()main.py
import os
import cv2 # Import OpenCV for reading images
import torch
import torchvision.transforms as transforms
from timm import create_model
import numpy as np
# Load the model
model_name = "efficientnet_b0"
model = create_model(model_name, pretrained=False, num_classes=5)
weight = torch.load('./weights2/efficientnet_b0_9.pth', map_location=torch.device('cpu'))
model.load_state_dict(weight['model_state_dict'])
model.eval() # Set the model to evaluation mode
# Label mapping dictionary
label_mapping = {0: 'airplane', 1: 'bridge', 2: 'palace', 3: 'ship', 4: 'stadium'}
# Define image transformations
transform = transforms.Compose([
transforms.ToTensor(), # Convert image to tensor
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)) # Normalize with ImageNet stats
])
def predict_single(img):
"""Predicts the label of a single image"""
# Convert BGR (OpenCV format) to RGB
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# Resize the image to match the input size expected by the model (256x256 in this case)
img = cv2.resize(img, (256, 256))
# Apply transformations: convert to tensor and normalize
img = transform(img).unsqueeze(0) # Add batch dimension
# Forward pass through the model
with torch.no_grad():
output = model(img)
# Get the predicted class (index with the highest score)
_, predicted_idx = torch.max(output, 1)
return predicted_idx.item()
def predict(img):
"""Performs Test-Time Augmentation (TTA) by predicting using original, horizontally flipped,
and vertically flipped images, and returns the final prediction by voting."""
# Original image prediction
original_pred = predict_single(img)
# Horizontal flip prediction
horizontal_flip_img = cv2.flip(img, 1)
horizontal_flip_pred = predict_single(horizontal_flip_img)
# Vertical flip prediction
vertical_flip_img = cv2.flip(img, 0)
vertical_flip_pred = predict_single(vertical_flip_img)
# Combine predictions and perform voting
predictions = [original_pred, horizontal_flip_pred, vertical_flip_pred]
final_pred = np.bincount(predictions).argmax() # Majority vote
return label_mapping[final_pred]
def main():
path = './test' # Path to the test directory
images = os.listdir(path) # List all images in the directory
# Loop through each image in the test folder
for image_file in images:
image_path = os.path.join(path, image_file)
img = cv2.imread(image_path)
# Run inference using TTA on the image
prediction = predict(img)
# Print the result (image name and its predicted label)
print(f"Image: {image_file} - Predicted Label: {prediction}")
if __name__ == "__main__":
main()鄙人（亚军）是基于resnet进行搭建的，其实就是泛化差了一点，我会在空闲时在github和csdn开源，图像分类，其实就是，运气分类罢了。
扫一扫
835
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
