教师情绪智能识别——调整教学策略，提高教学质量！【一键运行】

本项目旨在借助神经网络技术构建教师课堂情绪识别系统，以提升教学质量。数据集含7种人脸表情的jpg图片，训练集28204张、测试集7054张。通过数据预处理、搭建RepVGG模型、训练及预测等步骤，实现对教师情绪的识别，进而辅助调整教学策略。

一键运行

在现代教育体系中，教学质量是教师和学生共同关注的核心议题。教师作为知识的传授者和课堂的主导者，其情绪状态不仅直接影响到自身的教学热情和动力，更对学生的学习态度、课堂氛围以及最终的教学效果产生深远影响。然而，传统的教学评估方式往往侧重于知识传授的效果和学生的学习成绩，而忽视了教师在教学过程中的情绪变化及其对教学质量的潜在影响。

近年来，随着人工智能技术的飞速发展，特别是神经网络技术在图像识别、自然语言处理等领域的广泛应用，为教育领域带来了前所未有的变革机遇。神经网络技术以其强大的数据处理能力和模式识别能力，为教育数据的深度挖掘和智能分析提供了强有力的技术支持。在此背景下，开发一种能够实时、准确地识别教师课堂情绪状态的智能系统显得尤为重要。

本项目旨在通过运用先进的神经网络技术，构建一套“教师课堂情绪识别系统”。该系统能够自动捕捉并分析教师的面部表情特征，实时识别出教师的情绪状态（如高兴、平静、沮丧等），并基于这些情绪状态为教师提供个性化的教学策略调整建议。通过这样的智能辅助工具，教师可以更加直观地了解自己在课堂上的情绪表现，及时发现问题并进行调整，从而提升自身的教学能力，营造更加积极、高效的课堂氛围，最终实现教学质量的全面提升。

%%capture!unzip  /home/aistudio/data/data293196/expression.zip -d /home/aistudio/

import paddlefrom paddle.vision.datasets import DatasetFolderfrom paddle.vision import transforms# 定义训练集的数据增强和数据处理方式train_transform=transforms.Compose([transforms.ColorJitter(brightness=0.2),                                    transforms.Resize(128),                                    transforms.RandomHorizontalFlip(prob=0.5),                                    transforms.RandomRotation(degrees=7),                                    transforms.ToTensor(data_format='CHW'),                                    transforms.Normalize(mean=0.0, std=1.0, data_format='CHW')])train_dataset=DatasetFolder(root="/home/aistudio/expression/train",transform=train_transform)# 定义测试集的数据处理方test_transform=transforms.Compose([transforms.Resize(128),                                   transforms.ToTensor(data_format='CHW'),                                   transforms.Normalize(mean=0.0, std=1.0, data_format='CHW')])test_dataset=DatasetFolder(root="/home/aistudio/expression/test",transform=test_transform)print(f"训练集共有图片：{train_dataset.__len__()}张")print(f"测试集共有图片：{test_dataset.__len__()}张")print(f"总计有图片：{train_dataset.__len__()+test_dataset.__len__()}张")

训练集共有图片：28204张测试集共有图片：7054张总计有图片：35258张

import paddleimport  paddle.nn as nnfrom paddle.optimizer.lr import CosineAnnealingDecayfrom paddle.optimizer import AdamW

import warnings  warnings.filterwarnings("ignore")def conv_bn(in_channels, out_channels, kernel_size, stride, padding, groups=1):    result = paddle.nn.Sequential(        ('conv',nn.Conv2D(in_channels=in_channels, out_channels=out_channels,kernel_size=kernel_size, stride=stride, padding=padding, groups=groups, bias_attr=False)),        ('bn',nn.BatchNorm2D(num_features=out_channels))    )    return result# 构建RepVGGBlock模块class RepVGGBlock(nn.Layer):    def __init__(self, in_channels, out_channels, kernel_size,                 stride=1, padding=0, dilation=1, groups=1, padding_mode='zeros', deploy=False):        super(RepVGGBlock, self).__init__()        self.deploy = deploy             # deploy是推理部署的意思        self.groups = groups             # 输入的特征层分为几组，这是分组卷积概念，单卡GPU不用考虑，默认为1，分组卷积概念详见下面        self.in_channels = in_channels   # 输入通道        assert kernel_size == 3                  assert padding == 1              # 为什么这么设置呢，图像padding=1后经过 3x3 卷积之后图像大小不变                padding_11 = padding - kernel_size // 2                self.nonlinearity = nn.ReLU()        if deploy:            self.rbr_reparam = nn.Conv2D(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride,                                      padding=padding, dilation=dilation, groups=groups, bias_attr=True, padding_mode=padding_mode)        # 定义推理模型时，基本block就是一个简单的 conv2D               else:            self.rbr_identity = nn.BatchNorm2D(num_features=in_channels) if out_channels == in_channels and stride == 1 else None             # 直接连接，类似resnet残差连接，注意当输入通道和输出通道不同时候，只有 1x1 和 3x3 卷积，没有identity，下面网络图自己体会            self.rbr_dense = conv_bn(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride, padding=padding, groups=groups) #3x3卷积+BN            self.rbr_1x1 = conv_bn(in_channels=in_channels, out_channels=out_channels, kernel_size=1, stride=stride, padding=padding_11, groups=groups)          #1x1卷积+BN                def forward(self, inputs):        if hasattr(self, 'rbr_reparam'):            return self.nonlinearity(self.rbr_reparam(inputs))        # 推理阶段, conv2D 后 ReLU        if self.rbr_identity is None:            id_out = 0        else:            id_out = self.rbr_identity(inputs)        return self.nonlinearity(self.rbr_dense(inputs) + self.rbr_1x1(inputs) + id_out)        # 训练阶段，3x3、1x1、identity 相加后 ReLU    def get_equivalent_kernel_bias(self):        kernel3x3, bias3x3 = self._fuse_bn_tensor(self.rbr_dense)   # 卷积核两个参数 W 和 b 提出来        kernel1x1, bias1x1 = self._fuse_bn_tensor(self.rbr_1x1)        kernelid, biasid = self._fuse_bn_tensor(self.rbr_identity)  # 为啥可以提出两个参数，看论文公式                return kernel3x3 + self._pad_1x1_to_3x3_tensor(kernel1x1) + kernelid, bias3x3 + bias1x1 + biasid     def _pad_1x1_to_3x3_tensor(self, kernel1x1):        if kernel1x1 is None:            return 0        else:            return nn.functional.pad(kernel1x1, [1,1,1,1])    def _fuse_bn_tensor(self, branch):        if branch is None:            return 0, 0            # 当branch不是3x3、1x1、BN，那就返回 W=0, b=0        if isinstance(branch, nn.Sequential):            kernel = branch.conv.weight          # conv权重            running_mean = branch.bn._mean       # BN mean            running_var = branch.bn._variance    # BN var            gamma = branch.bn.weight             # BN γ             beta = branch.bn.bias                # BN β            eps = branch.bn._epsilon             # 防止分母为0            # 当branch是3x3、1x1时候，返回以上数据，为后面做融合        else:            assert isinstance(branch, nn.BatchNorm2D)            if not hasattr(self, 'id_tensor'):                input_dim = self.in_channels // self.groups                                       # 通道分组，单个GPU不用考虑，详情去搜索分组卷积                kernel_value = np.zeros((self.in_channels, input_dim, 3, 3), dtype=np.float32)    # 定义新的3x3卷积核，参数为0，这里用到DepthWise，详情去搜索MobileNetV1                                                                                                  # 这部分看后面讲解                for i in range(self.in_channels):                    kernel_value[i, i % input_dim, 1, 1] = 1                                      # 将卷积核对角线部分赋予1                self.id_tensor = paddle.to_tensor(kernel_value)            kernel = self.id_tensor               # conv权重                   running_mean = branch._mean           # BN mean            running_var = branch._variance        # BN var            gamma = branch.weight                 # BN γ            beta = branch.bias                    # BN β            eps = branch._epsilon                 # 防止分母为0        std = (running_var + eps).sqrt()        t = (gamma / std).reshape((-1, 1, 1, 1))        return kernel * t, beta - running_mean * gamma / std    def repvgg_convert(self):        kernel, bias = self.get_equivalent_kernel_bias()        return kernel.numpy(), bias.numpy()# 构建RepVGGBlock模块class RepVGGBlock(nn.Layer):    def __init__(self, in_channels, out_channels, kernel_size,                 stride=1, padding=0, dilation=1, groups=1, padding_mode='zeros', deploy=False):        super(RepVGGBlock, self).__init__()        self.deploy = deploy             # deploy是推理部署的意思        self.groups = groups             # 输入的特征层分为几组，这是分组卷积概念，单卡GPU不用考虑，默认为1，分组卷积概念详见下面        self.in_channels = in_channels   # 输入通道        assert kernel_size == 3                  assert padding == 1              # 为什么这么设置呢，图像padding=1后经过 3x3 卷积之后图像大小不变                padding_11 = padding - kernel_size // 2                self.nonlinearity = nn.ReLU()        if deploy:            self.rbr_reparam = nn.Conv2D(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride,                                      padding=padding, dilation=dilation, groups=groups, bias_attr=True, padding_mode=padding_mode)        # 定义推理模型时，基本block就是一个简单的 conv2D               else:            self.rbr_identity = nn.BatchNorm2D(num_features=in_channels) if out_channels == in_channels and stride == 1 else None             # 直接连接，类似resnet残差连接，注意当输入通道和输出通道不同时候，只有 1x1 和 3x3 卷积，没有identity，下面网络图自己体会            self.rbr_dense = conv_bn(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride, padding=padding, groups=groups) #3x3卷积+BN            self.rbr_1x1 = conv_bn(in_channels=in_channels, out_channels=out_channels, kernel_size=1, stride=stride, padding=padding_11, groups=groups)          #1x1卷积+BN    def forward(self, inputs):        if hasattr(self, 'rbr_reparam'):            return self.nonlinearity(self.rbr_reparam(inputs))        # 推理阶段, conv2D 后 ReLU        if self.rbr_identity is None:            id_out = 0        else:            id_out = self.rbr_identity(inputs)        return self.nonlinearity(self.rbr_dense(inputs) + self.rbr_1x1(inputs) + id_out)        # 训练阶段，3x3、1x1、identity 相加后 ReLU    def get_equivalent_kernel_bias(self):        kernel3x3, bias3x3 = self._fuse_bn_tensor(self.rbr_dense)   # 卷积核两个参数 W 和 b 提出来        kernel1x1, bias1x1 = self._fuse_bn_tensor(self.rbr_1x1)        kernelid, biasid = self._fuse_bn_tensor(self.rbr_identity)  # 为啥可以提出两个参数，看论文公式                return kernel3x3 + self._pad_1x1_to_3x3_tensor(kernel1x1) + kernelid, bias3x3 + bias1x1 + biasid     def _pad_1x1_to_3x3_tensor(self, kernel1x1):        if kernel1x1 is None:            return 0        else:            return nn.functional.pad(kernel1x1, [1,1,1,1])    def _fuse_bn_tensor(self, branch):        if branch is None:            return 0, 0            # 当branch不是3x3、1x1、BN，那就返回 W=0, b=0        if isinstance(branch, nn.Sequential):            kernel = branch.conv.weight          # conv权重            running_mean = branch.bn._mean       # BN mean            running_var = branch.bn._variance    # BN var            gamma = branch.bn.weight             # BN γ             beta = branch.bn.bias                # BN β            eps = branch.bn._epsilon             # 防止分母为0            # 当branch是3x3、1x1时候，返回以上数据，为后面做融合        else:            assert isinstance(branch, nn.BatchNorm2D)            if not hasattr(self, 'id_tensor'):                input_dim = self.in_channels // self.groups                                       # 通道分组，单个GPU不用考虑，详情去搜索分组卷积                kernel_value = np.zeros((self.in_channels, input_dim, 3, 3), dtype=np.float32)    # 定义新的3x3卷积核，参数为0，这里用到DepthWise，详情去搜索MobileNetV1                                                                                                  # 这部分看后面讲解                for i in range(self.in_channels):                    kernel_value[i, i % input_dim, 1, 1] = 1                                      # 将卷积核对角线部分赋予1                self.id_tensor = paddle.to_tensor(kernel_value)            kernel = self.id_tensor               # conv权重                   running_mean = branch._mean           # BN mean            running_var = branch._variance        # BN var            gamma = branch.weight                 # BN γ            beta = branch.bias                    # BN β            eps = branch._epsilon                 # 防止分母为0            # 当branch是 identity，也即只有BN时候返回以上数据        std = (running_var + eps).sqrt()        t = (gamma / std).reshape((-1, 1, 1, 1))        # 提取W、b，不管你是 3x3 1x1 identity都要提取        return kernel * t, beta - running_mean * gamma / std    def repvgg_convert(self):        kernel, bias = self.get_equivalent_kernel_bias()        return kernel.numpy(), bias.numpy()class RepVGG(nn.Layer):    def __init__(self, num_blocks, num_classes=1000, width_multiplier=None, override_groups_map=None, deploy=False):        super(RepVGG, self).__init__()        assert len(width_multiplier) == 4 # 江湖人称瘦身因子，减小网络的宽度，就是输出通道乘以权重变小还是变大        self.deploy = deploy        self.override_groups_map = override_groups_map or dict() # 这部分是分组卷积，单个GPU不用考虑        assert 0 not in self.override_groups_map        self.in_planes = min(64, int(64 * width_multiplier[0]))        self.stage0 = RepVGGBlock(in_channels=3, out_channels=self.in_planes, kernel_size=3, stride=2, padding=1, deploy=self.deploy)        self.cur_layer_idx = 1                          # 分组卷积        self.stage1 = self._make_stage(int(64 * width_multiplier[0]), num_blocks[0], stride=2)        self.stage2 = self._make_stage(int(128 * width_multiplier[1]), num_blocks[1], stride=2)        self.stage3 = self._make_stage(int(256 * width_multiplier[2]), num_blocks[2], stride=2)        self.stage4 = self._make_stage(int(512 * width_multiplier[3]), num_blocks[3], stride=2)        self.gap = nn.AdaptiveAvgPool2D(output_size=1)  # 全局池化，变成 Nx1x1（CxHxW），类似 flatten        self.linear = nn.Linear(int(512 * width_multiplier[3]), num_classes)            def _make_stage(self, planes, num_blocks, stride):        strides = [stride] + [1]*(num_blocks-1)        blocks = []        for stride in strides:            cur_groups = self.override_groups_map.get(self.cur_layer_idx, 1) # 分组卷积            blocks.append(RepVGGBlock(in_channels=self.in_planes, out_channels=planes, kernel_size=3,                                      stride=stride, padding=1, groups=cur_groups, deploy=self.deploy))            self.in_planes = planes            self.cur_layer_idx += 1        return nn.Sequential(*blocks)    def forward(self, x):        out = self.stage0(x)        out = self.stage1(out)        out = self.stage2(out)        out = self.stage3(out)        out = self.stage4(out)        out = self.gap(out)        out = paddle.flatten(out,start_axis=1)        out = self.linear(out)        return outdef create_RepVGG_B2(deploy=False,num_classes=7):    return RepVGG(num_blocks=[4, 6, 16, 1], num_classes=num_classes,                  width_multiplier=[2.5, 2.5, 2.5, 5], override_groups_map=None, deploy=deploy)model=create_RepVGG_B2(num_classes=7)

import warnings  warnings.filterwarnings("ignore")paddle.jit.save(model, '/home/aistudio/work/repvgg', [paddle.static.InputSpec([-1,3,128,128])])

model=paddle.Model(model)scheduler = CosineAnnealingDecay(    learning_rate=0.01,    T_max=80,)                            # 定义学习率衰减器opti = AdamW(    learning_rate=scheduler,    parameters=model.parameters(),    weight_decay=1e-5)                            # 定义Adam优化器model.prepare(optimizer=opti,loss=paddle.nn.CrossEntropyLoss(), metrics=paddle.metric.Accuracy())

callback = paddle.callbacks.VisualDL(log_dir='work/log_dir')model.fit(train_data=train_dataset,     # 指定训练集            eval_data=test_dataset,     # 指定验证集            batch_size=256,             # 一次性读取样本数            epochs=80,                 # 总共训练的轮数            eval_freq=1,                # 每隔1轮测试一次            verbose=1,                  # 输出级别            save_dir="work/output/",         # 权重等文件保存地址            num_workers=6,              # 多线程用于加快数据读取            callbacks=[callback])       # 将VisualDL指定进去

model=create_RepVGG_B2(num_classes=7)

import cv2import paddlefrom paddle.vision import transformsimport matplotlib.pyplot as pltlabel={0:'anger',1:'disgust',2:'fear',3:'happy',4:'sad',5:'surprised',6:'normal'}# 加载训练好的权重文件，该网络已经具备表情识别的能力best_model_path = "/home/aistudio/work/output/final.pdparams"para_state_dict = paddle.load(best_model_path)model.eval() # 测试时要设置eval模式model.set_state_dict(para_state_dict)# 加载一张图片并进行预处理img=cv2.imread("/home/aistudio/2.png")img=cv2.cvtColor(img,cv2.COLOR_BGR2RGB)     # cv2默认是BGR模式img=cv2.resize(img,(128,128))                 input_tensor=transforms.to_tensor(img, data_format='CHW')       # 转为paddle.tensor类型input_tensor=paddle.unsqueeze(input_tensor,axis=0)  #因为输出shape应为(b,c,h,w)，而现在是(c,h,w)，所以升维变成(1,c,h,w)从而符合模型的输入格式# 推理图片获取识别结果test_result = model(input_tensor)   # 输出会给出7个类的概率值，而最大值所在的类就是预测结果max_prob_index=paddle.argmax(test_result[0])# 展示图片和预测结果plt.figure()plt.title('predict: {}'.format(label[int(max_prob_index)]))plt.imshow(img)plt.show()

<Figure size 640x480 with 1 Axes>

以上就是教师情绪智能识别——调整教学策略，提高教学质量！【一键运行】的详细内容，更多请关注乐哥常识网其它相关文章！