基于ResNet50 实现教师课堂情绪识别

!unzip -oq /home/aistudio/data/data293302/emoji.zip -d /home/aistudio/work

# 查看图片的数据量import osdef count_images(directory):
    # 支持的图片文件扩展名列表
    image_extensions = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff']    # 遍历目录中的所有子文件夹
    for folder in os.listdir(directory):
        folder_path = os.path.join(directory, folder)        if os.path.isdir(folder_path):            # 统计当前文件夹中的图片数量
            image_count = sum([1 for file in os.listdir(folder_path) if os.path.splitext(file)[1].lower() in image_extensions])            print(f"{folder}: {image_count} images")

directory_path = '/home/aistudio/work/emoji'count_images(directory_path)

# 查看图片的宽高和通道import osfrom PIL import Imagedef get_first_image_shape(directory):
    # 支持的图片文件扩展名列表
    image_extensions = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff']    # 遍历目录中的所有子文件夹
    for folder in os.listdir(directory):
        folder_path = os.path.join(directory, folder)        if os.path.isdir(folder_path):            # 遍历文件夹中的文件，找到第一个图片文件
            for file in os.listdir(folder_path):                if os.path.splitext(file)[1].lower() in image_extensions:
                    image_path = os.path.join(folder_path, file)                    try:                        with Image.open(image_path) as img:
                            width, height = img.size
                            mode = img.mode
                            channels = 1 if mode == 'L' else 3 if mode in ('RGB', 'P') else 4 if mode == 'RGBA' else 'Unknown'
                            print(f"{folder}: {width}x{height}, Channels: {channels}")                        break  # 找到第一个图片后停止搜索
                    except Exception as e:                        print(f"Error opening {image_path}: {e}")                        break  # 如果无法打开图片，也停止搜索# 替换为你的文件夹路径directory_path = '/home/aistudio/work/emoji'get_first_image_shape(directory_path)

#导入相关库import numpy as np 
import paddlefrom paddle.io import DataLoaderfrom paddle.vision.models import resnet50,resnet18,resnetfrom paddle.vision import transformsfrom PIL import Imagefrom paddle.io import Subsetimport matplotlib.pyplot as pltimport randomimport osfrom paddle.vision.transforms import Compose, RandomRotation, Resize, ToTensor, Normalizefrom paddle import nnfrom paddle import optimizerfrom paddle.vision.datasets import DatasetFolder

# 数据预处理transform = transforms.Compose([
    transforms.RandomRotation(20),
    transforms.Resize((48, 48)),
    transforms.ToTensor(), 
    transforms.Normalize(mean=(0.5,), std=(0.5,))
])
train_data_path = "/home/aistudio/work/emoji"train_data = DatasetFolder(root=train_data_path,transform=transform)

#查看labeltrain_data.class_to_idx

#划分train数据集和train_val数据集batch_size = 64val_fraction = 0.3data_size = len(train_data)
val_split = int(np.floor(data_size * val_fraction))
indices = list(range(data_size))

np.random.seed(42)
np.random.shuffle(indices)

val_indices, train_indices = indices[:val_split], indices[val_split:]

train_sampler = paddle.io.Subset(train_data, train_indices)
val_sampler = paddle.io.Subset(train_data,val_indices)#读取数据集train_loader = DataLoader(
    dataset=train_sampler,
    batch_size=batch_size,
)

val_loader = DataLoader(
    dataset=val_sampler,
    batch_size=batch_size,
)

i = 0fig = plt.figure(figsize=(15, 3))for image, label in val_loader:    if i == 7: break
        
    ax = fig.add_subplot(1, 7, i+1)
    plt.imshow(image[1].transpose((1, 2, 0))) 
    if(label[0] == 0):
        plt.title('Angry')    elif(label[0] == 1):
        plt.title('disgust')    elif(label[0] == 2):
        plt.title('fear')    elif(label[0] == 3):
        plt.title('happy')    elif(label[0] == 4):
        plt.title('neutral')    elif(label[0] == 5):
        plt.title('sad')    elif(label[0] == 6):
        plt.title('surprise')
    i += 1
    plt.axis('off')
plt.show()

model = resnet50(pretrained=True,num_classes=7)
criterion = nn.CrossEntropyLoss()
optimizer = optimizer.Adam(learning_rate=1e-3,parameters=model.parameters(), weight_decay=1e-5)

# 模型训练def train_model(model, train_loader, val_loader, optimizer, criterion, num_epochs):
    train_history = []
    val_history = []
    train_loss_history = []
    val_loss_history = []    
    for epoch in range(num_epochs):
        model.train()
        
        running_loss = 0.0
        correct_samples = 0
        total_samples = 0
        
        for idx, (X, y) in enumerate(train_loader):            
            predictions = model(X)
            loss = criterion(predictions, y)
            
            optimizer.clear_grad()
            loss.backward()
            optimizer.step()
            
            indices = paddle.argmax(predictions, 1)
            correct_samples += paddle.sum(indices == y)
            total_samples += y.shape[0]
            
            running_loss += loss
            
        train_accuracy = float(correct_samples) / total_samples
        val_accuracy, val_loss = evaluate_model(model, val_loader, criterion)
        ave_loss = running_loss / (idx + 1)
        
        train_loss_history.append(float(ave_loss))
        val_loss_history.append(float(val_loss))
        train_history.append(train_accuracy)
        val_history.append(val_accuracy)        if epoch >= 80:
            paddle.save(model.state_dict(), '/home/aistudio/work/model/acc{}.model'.format(val_accuracy))                
        print("Train loss: %f, Val loss: %f, Train accuracy: %f, Val accuracy: %f" % (ave_loss, val_loss, train_accuracy, val_accuracy))    
    return train_loss_history, val_loss_history, train_history, val_history        
# 模型评估def evaluate_model(model, loader, criterion):
    with paddle.no_grad():
        model.eval()

        correct_samples = 0
        total_samples = 0
        running_loss = 0.0

        for idx, (X, y) in enumerate(loader):

            predictions = model(X)
            loss = criterion(predictions, y)

            indices = paddle.argmax(predictions, 1)
            correct_samples += paddle.sum(indices == y)
            total_samples += y.shape[0]

            running_loss += loss

        accuracy = float(correct_samples) / total_samples
        ave_loss = running_loss / (idx + 1)        return accuracy, ave_loss

train_loss_history, val_loss_history, train_history, val_history = train_model(model, train_loader, val_loader, optimizer, criterion,100)

# 训练结果可视化（这里由于训练的数据集和训练轮数，导致效果并不是很好）plt.xlabel("Epoch")
plt.ylabel("Accuracy")
plt.plot(train_history)
plt.plot(val_history)
plt.show()

plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.plot(train_loss_history)
plt.plot(val_loss_history)
plt.show()

def show_image_with_labels(image, y_true, y_pred):
    plt.figure(figsize=(15, 7))
    image = paddle.transpose(image, perm=[1, 2,0])
    plt.imshow(image)    if(y_true == 0):
        plt.title(f'Predicted  emotion: Angry')    elif(y_true == 1):
        plt.title(f'Predicted  emotion: disgust')    elif(y_true == 2):
        plt.title(f'Predicted  emotion: fear')    elif(y_true == 3):
        plt.title(f'Predicted  emotion: Happy')    elif(y_true == 4):
        plt.title(f'Predicted  emotion: neutral')    elif(y_true == 5):
        plt.title(f'Predicted  emotion: sad')    elif(y_true == 6):
        plt.title(f'Predicted  emotion: surprise')
    plt.axis('off')  
    plt.show()

batch_images, batch_labels = next(iter(val_loader))with paddle.no_grad():
    model.eval()    for idx, image in enumerate(batch_images):        if idx == 7: break

        image_inference = image.unsqueeze(0)
        label_inference = batch_labels[idx]

        output = model(image_inference)

        y_pred = np.argmax(paddle.Tensor.cpu(output).numpy(), axis=1)[0]
        
        show_image_with_labels(image, y_pred, batch_labels[idx])

!pip install python-opencv

# 模型推理import cv2import matplotlib.pyplot as plt
labels={    0:'anger',    1:'disgust',    2:'happy',    3:'fear',    4:'neutral',    5:'sad',    6:'surprise'}# 加载训练好的模型pre_model = paddle.vision.models.resnet50(pretrained=True, num_classes=7)
pre_model.set_state_dict(paddle.load('/home/aistudio/work/model/acc0.5974363737692736.model'))
pre_model.eval()

test_path = "/home/aistudio/test"# 生成预测结果for path_1 in os.listdir(test_path):

    image_path = os.path.join(test_path, path_1)    if path_1.endswith(".jpg"):

        image = np.array(Image.open(image_path))    # H, W, C
        try:
            image = image.transpose([2, 0, 1])[:3]  # C, H, W
        except:
            image = np.array([image, image, image]) # C, H, W
        
        # 加载一张图片并进行预处理
        imge=cv2.imread(image_path)
        imge=cv2.cvtColor(imge,cv2.COLOR_BGR2RGB)                   
        input_tensor=transforms.to_tensor(imge, data_format='CHW')
        input_tensor=paddle.unsqueeze(input_tensor,axis=0)  #c,h,w

        # 推理图片获取识别结果
        pre = list(np.array(pre_model(input_tensor)[0]))
        max_item = max(pre)
        pre = pre.index(max_item)        # 展示图片和预测结果
        plt.figure()
        plt.title('predict: {}'.format(labels[int(pre)]))
        plt.imshow(imge)
        plt.show()