深度学习复盘与论文复现A

文章目录

  • 一、查漏补缺复盘
    • 1、python中zip()用法
    • 2、Tensor和tensor的区别
    • 3、计算图中的迭代取数
    • 4、nn.Modlue及nn.Linear 源码理解
    • 5、知识杂项思考列表
    • 6、KL散度初步理解
  • 二、处理多维特征的输入
    • 1、逻辑回归模型流程
    • 2、Mini-Batch (N samples)
  • 三、加载数据集
    • 1、Python 魔法方法介绍
    • 2、Epoch,Batch-Size,Iteration区别
    • 3、加载相关数据集的实现
    • 4、在torchvision,datasets数据集
  • 四、多分类问题
    • 1、softmax 再探究
    • 2、独热编码问题
  • 五、语言模型初步理解
  • 六、论文复现准备工作
    • 1、简易实现小项目代码地址
    • 2、简易实现小项目运行过程
    • 3、抑郁症数据预处理运行过程
    • 4、抑郁症数据训练运行过程
  • 七、遇到问题及其解决方案
    • 1、pycharm 不能使用GPU加速训练
    • 2、google.protobuf.internal冲突问题

一、查漏补缺复盘

1、python中zip()用法

python中zip()用法

应用举例

import numpy as np
import matplotlib.pyplot as plt
 
x_data = [1.0, 2.0, 3.0]
y_data = [2.0, 4.0, 6.0]
 
 
def forward(x):
    return x*w
 
 
def loss(x, y):
    y_pred = forward(x)
    return (y_pred - y)**2
 
 
# 穷举法
w_list = []
mse_list = []
for w in np.arange(0.0, 4.1, 0.1):
    print("w=", w)
    l_sum = 0
    for x_val, y_val in zip(x_data, y_data):
        y_pred_val = forward(x_val)
        loss_val = loss(x_val, y_val)
        l_sum += loss_val
        print('\t', x_val, y_val, y_pred_val, loss_val)
    print('MSE=', l_sum/3)
    w_list.append(w)
    mse_list.append(l_sum/3)
    
plt.plot(w_list,mse_list)
plt.ylabel('Loss')
plt.xlabel('w')
plt.show()    

2、Tensor和tensor的区别

首先看下代码区别

>>> a=torch.Tensor([1,2])
>>> a
tensor([1., 2.])
>>> a=torch.tensor([1,2])
>>> a
tensor([1, 2])
  • torch.Tensor()是python类,更明确地说,是默认张量类型torch.FloatTensor()的别名,torch.Tensor([1,2])会调用Tensor类的构造函数__init__,生成单精度浮点类型的张量。
  • torch.tensor()仅仅是python函数:https://pytorch.org/docs/stable/torch.html torch.tensor
torch.tensor(data, dtype=None, device=None, requires_grad=False)
  • 其中data可以是:list, tuple, NumPy ndarray, scalar和其他类型。
    torch.tensor会从data中的数据部分做拷贝(而不是直接引用),根据原始数据类型生成相应的torch.LongTensor、torch.FloatTensor和torch.DoubleTensor。

3、计算图中的迭代取数

注意关注grad取元素规则

import torch
x_data = [1.0, 2.0, 3.0]
y_data = [2.0, 4.0, 6.0]
 
w = torch.tensor([1.0]) # w的初值为1.0
w.requires_grad = True # 需要计算梯度
 
def forward(x):
    return x*w  # w是一个Tensor
 
 
def loss(x, y):
    y_pred = forward(x)
    return (y_pred - y)**2
 
print("predict (before training)", 4, forward(4).item())
 
for epoch in range(100):
    for x, y in zip(x_data, y_data):
        l =loss(x,y) # l是一个张量,tensor主要是在建立计算图 forward, compute the loss
        l.backward() #  backward,compute grad for Tensor whose requires_grad set to True
        print('\tgrad:', x, y, w.grad.item())
        w.data = w.data - 0.01 * w.grad.data   # 权重更新时,注意grad也是一个tensor
 
        w.grad.data.zero_() # after update, remember set the grad to zero
 
    print('progress:', epoch, l.item()) # 取出loss使用l.item,不要直接使用l(l是tensor会构建计算图)
 
print("predict (after training)", 4, forward(4).item())

.data等于进tensor修改,.item()等于把数拿出来

  • w是Tensor(张量类型),Tensor中包含data和grad,data和grad也是Tensor。grad初始为None,调用l.backward()方法后w.grad为Tensor,故更新w.data时需使用w.grad.data。如果w需要计算梯度,那构建的计算图中,跟w相关的tensor都默认需要计算梯度。
    在这里插入图片描述

下面的 Linear(1,1 )是input1,output1

在这里插入图片描述
在这里插入图片描述

4、nn.Modlue及nn.Linear 源码理解

import torch
# prepare dataset
# x,y是矩阵,3行1列 也就是说总共有3个数据,每个数据只有1个特征
x_data = torch.tensor([[1.0], [2.0], [3.0]])
y_data = torch.tensor([[2.0], [4.0], [6.0]])
 
 
class LinearModel(torch.nn.Module):
    def __init__(self):
        super(LinearModel, self).__init__()
        # (1,1)是指输入x和输出y的特征维度,这里数据集中的x和y的特征都是1维的
        # 该线性层需要学习的参数是w和b  获取w/b的方式分别是~linear.weight/linear.bias
        self.linear = torch.nn.Linear(1, 1)
 
    def forward(self, x):
        y_pred = self.linear(x)
        return y_pred
 
model = LinearModel()
 
# construct loss and optimizer
# criterion = torch.nn.MSELoss(size_average = False)
criterion = torch.nn.MSELoss(reduction = 'sum')
optimizer = torch.optim.SGD(model.parameters(), lr = 0.01) # model.parameters()自动完成参数的初始化操作,这个地方我可能理解错了
 
# training cycle forward, backward, update
for epoch in range(100):
    y_pred = model(x_data) # forward:predict
    loss = criterion(y_pred, y_data) # forward: loss
    print(epoch, loss.item())
 
    optimizer.zero_grad() # the grad computer by .backward() will be accumulated. so before backward, remember set the grad to zero
    loss.backward() # backward: autograd,自动计算梯度
    optimizer.step() # update 参数,即更新w和b的值
 
print('w = ', model.linear.weight.item())
print('b = ', model.linear.bias.item())
 
x_test = torch.tensor([[4.0]])
y_test = model(x_test)
print('y_pred = ', y_test.data)

参考文章

import torch
from torch import nn

m = nn.Linear(20, 30)
input = torch.randn(128, 20)
output = m(input)

output.size()   # torch.Size([128, 30])

  • nn.Module 是所有神经网络单元(neural network modules)的基类
    pytorch在nn.Module中,实现了__call__方法,而在__call__方法中调用了forward函数。
  • 首先创建类对象m,然后通过m(input)实际上调用__call__(input),然后__call__(input)调用
    forward()函数,最后返回计算结果为:[ 128 , 20 ] × [ 20 , 30 ] = [ 128 , 30 ]

在这里插入图片描述

链接

5、知识杂项思考列表

1、SGD单个样本进行梯度下降容易被噪声带来巨大干扰

2、矩阵求导理论书籍 matrix cookbook

3、前向传播是为了计算损失值,反向传播是为了计算梯度来更新模型的参数

6、KL散度初步理解

  • KL散度(Kullback-Leibler divergence)是两个概率分布间差异的非对称性度量。参与计算的一个概率分布为真实分布,另一个为理论(拟合)分布,相对熵表示使用理论分布拟合真实分布时产生的信息损耗

KL散度具有以下几个性质:

  1. 非负性:KL散度的值始终大于等于0,当且仅当两个概率分布完全相同时,KL散度的值才为0。
  2. 不对称性:KL散度具有方向性,即P到Q的KL散度与Q到P的KL散度不相等。
  3. 无限制性:KL散度的值可能为无穷大,即当真实分布中的某个事件在理论分布中的概率为0时,KL散度的值为无穷大。

KL散度的计算公式如下:

D K L ( P ∣ ∣ Q ) = ∑ i P ( i ) log ⁡ P ( i ) Q ( i ) D_{KL}(P||Q) = \sum_{i}P(i) \log \frac{P(i)}{Q(i)} DKL(P∣∣Q)=iP(i)logQ(i)P(i)

其中,(P)和(Q)分别为两个概率分布,(P(i))和(Q(i))分别表示在位置(i)处的概率值。当KL散度等于0时,表示两个概率分布完全相同;当KL散度大于0时,表示两个概率分布存在差异,且值越大差异越大。

  • 在机器学习中,KL散度有广泛的应用,例如用于衡量两个概率分布之间的差异,或者用于优化生成式模型的损失函数等。此外,KL散度还可以用于基于KL散度的样本选择来有效训练支持向量机(SVM)等算法,以解决SVM在大型数据集合上效率低下的问题。

逻辑回归构造模板
在这里插入图片描述

二、处理多维特征的输入

1、逻辑回归模型流程

在这里插入图片描述

2、Mini-Batch (N samples)

在数学上转化为矩阵运算,转化为向量形式利于GPU进行并行运算
在这里插入图片描述

self.linear torch.nn.Linear (8,1) 输入为8,输出为1

说明:

  • 1、乘的权重(w)都一样,加的偏置(b)也一样。b变成矩阵时使用广播机制。神经网络的参数w和b是网络需要学习的,其他是已知的。

  • 2、学习能力越强,有可能会把输入样本中噪声的规律也学到。我们要学习数据本身真实数据的规律,学习能力要有泛化能力。

  • 3、该神经网络共3层;第一层是8维到6维的非线性空间变换,第二层是6维到4维的非线性空间变换,第三层是4维到1维的非线性空间变换。
    在这里插入图片描述

  • 4、本算法中torch.nn.Sigmoid() 将其看作是网络的一层,而不是简单的函数使用

torch.sigmoid、torch.nn.Sigmoid和torch.nn.functional.sigmoid的区别

三、加载数据集

  • DataLoader 主要加载数据集

说明:

  • 1、DataSet 是抽象类,不能实例化对象,主要是用于构造我们的数据集

  • 2、DataLoader 需要获取DataSet提供的索引[i]和len;用来帮助我们加载数据,比如说做shuffle(提高数据集的随机性),batch_size,能拿出Mini-Batch进行训练。它帮我们自动完成这些工作。DataLoader可实例化对象。
    在这里插入图片描述

  • 3、__getitem__目的是为支持下标(索引)操作

1、Python 魔法方法介绍

  • 在Python中,有一些特殊的方法(通常被称为“魔法方法”或“双下划线方法”)是由Python解释器预定义的,它们允许对象进行某些特殊的操作或重载常见的运算符。这些魔法方法通常以双下划线(__)开始和结束。
  1. 初始化方法__init__(self, ...)

在创建对象时自动调用,用于初始化对象的状态。

class MyClass:
    def __init__(self, value):
        self.value = value
  1. 字符串表示方法__str__(self)__repr__(self)

用于定义对象的字符串表示。__str__用于在print函数中,而__repr__用于在repr函数中。

class MyClass:
    def __init__(self, value):
        self.value = value
    
    def __str__(self):
        return f"MyClass({self.value})"
    
    def __repr__(self):
        return f"MyClass({self.value})"
  1. 比较方法:如 __eq__(self, other)__lt__(self, other)

用于定义对象之间的比较操作。

class MyClass:
    def __init__(self, value):
        self.value = value
    
    def __eq__(self, other):
        if isinstance(other, MyClass):
            return self.value == other.value
        return False
  1. 算术运算符方法:如 __add__(self, other)__sub__(self, other)

用于定义对象之间的算术运算。

class MyClass:
    def __init__(self, value):
        self.value = value
    
    def __add__(self, other):
        if isinstance(other, MyClass):
            return MyClass(self.value + other.value)
        return NotImplemented
  1. 容器方法:如 __len__(self)__getitem__(self, key)__setitem__(self, key, value)
  • 用于定义对象作为容器(如列表、字典等)时的行为。

  • 每个魔法方法是python的内置方法。方法都有对应的内置函数,或者运算符,对这个对象使用这些函数或者运算符时就会调用类中的对应魔法方法,可以理解为重写这些python的内置函数

2、Epoch,Batch-Size,Iteration区别

在这里插入图片描述
eg:

10,000 examples --> 1000 Batch-size --> 10 Iteration

1、需要mini_batch 就需要import DataSet和DataLoader

2、继承DataSet的类需要重写init,getitem,len魔法函数。分别是为了加载数据集,获取数据索引,获取数据总量。

3、DataLoader对数据集先打乱(shuffle),然后划分成mini_batch。

4、len函数的返回值 除以 batch_size 的结果就是每一轮epoch中需要迭代的次数。

5、inputs, labels = data中的inputs的shape是[32,8],labels 的shape是[32,1]。也就是说mini_batch在这个地方体现的

在windows 下 wrap 和 linux 下 fork 代码优化

在这里插入图片描述

3、加载相关数据集的实现

import  torch
import  numpy as np
from torch.utils.data import Dataset
from torch.utils.data import DataLoader

 
class DiabetesDataset(Dataset):
    def __init__(self,filepath):
        xy = np.loadtxt(filepath,delimiter=',',dtype=np.float32)
        #shape本身是一个二元组(x,y)对应数据集的行数和列数,这里[0]我们取行数,即样本数
        self.len = xy.shape[0]
        self.x_data = torch.from_numpy(xy[:, :-1])
        self.y_data = torch.from_numpy(xy[:, [-1]])

    def __getitem__(self, index):
        return self.x_data[index],self.y_data[index]

    def __len__(self):
        return self.len
        
#定义好DiabetesDataset后我们就可以实例化他了
dataset = DiabetesDataset('./data/Diabetes_class.csv.gz')
#我们用DataLoader为数据进行分组,batch_size是一个组中有多少个样本,shuffle表示要不要对样本进行随机排列
#一般来说,训练集我们随机排列,测试集不。num_workers表示我们可以用多少进程并行的运算
train_loader = DataLoader(dataset=dataset,batch_size=32,shuffle=True,num_workers=2)

class Model(torch.nn.Module):
    def __init__(self):#构造函数
        super(Model,self).__init__()
        self.linear1 = torch.nn.Linear(8,6)#8维到6维
        self.linear2 = torch.nn.Linear(6, 4)#6维到4维
        self.linear3 = torch.nn.Linear(4, 1)#4维到1维
        self.sigmoid = torch.nn.Sigmoid()#因为他里边也没有权重需要更新,所以要一个就行了,单纯的算个数


    def forward(self, x):#构建一个计算图,就像上面图片画的那样
        x = self.sigmoid(self.linear1(x))
        x = self.sigmoid(self.linear2(x))
        x = self.sigmoid(self.linear3(x))
        return  x

model = Model()#实例化模型

criterion = torch.nn.BCELoss(size_average=False)
#model.parameters()会扫描module中的所有成员,如果成员中有相应权重,那么都会将结果加到要训练的参数集合上
optimizer = torch.optim.SGD(model.parameters(),lr=0.1)#lr为学习率

if __name__=='__main__':#if这条语句在windows系统下一定要加,否则会报错
    for epoch in range(1000):
        for i,data in enumerate(train_loader,0):#取出一个bath
            # repare data
            inputs,labels = data#将输入的数据赋给inputs,结果赋给labels 
            #Forward
            y_pred = model(inputs)
            loss = criterion(y_pred,labels)
            print(epoch,loss.item())
            #Backward
            optimizer.zero_grad()
            loss.backward()
            #update
            optimizer.step()


4、在torchvision,datasets数据集

在torchvision,datasets 下的常见数据集
在这里插入图片描述

四、多分类问题

1、softmax 再探究

在这里插入图片描述
每个类别输出都使用二分类的交叉熵,这样的话所有类别都是一个独立的分布,概率加起来不等于一

注意:我们是将每一个类别看作一个二分类问题,且最后每个输出值需满足两个要求:①≥ 0 ②∑ = 1 即输出的是一个分布。

在神经网络中,特别是在分类任务中,Softmax 函数通常被用作最后一层(线性层或全连接层)的激活函数,以将模型的输出转换为概率分布。对于给定向

Softmax ( Z l ) i = e Z i l ∑ j = 1 k e Z j l \text{Softmax}(Z^l)_i = \frac{e^{Z^l_i}}{\sum_{j=1}^{k} e^{Z^l_j}} Softmax(Zl)i=j=1keZjleZil 对于 i = 0 … … K − 1 \quad \text{对于} \quad i = 0……K-1 对于i=0……K1

除法是因为归一化

因为输出的是概率,所以要是正数;k个类的概率相互抑制,概率之和是1.所以要先转正再归一化,也就是softmax

  • 在分类任务中,特别是当使用交叉熵损失函数(Cross-Entropy Loss)时,对于给定的预测概率分布 Y ^ \hat{Y} Y^和真实标签 Y,损失函数可以定义为:

Loss ( Y ^ , Y ) = − ∑ i = 1 k Y i log ⁡ Y ^ i \text{Loss}(\hat{Y}, Y) = -\sum_{i=1}^{k} Y_i \log \hat{Y}_i Loss(Y^,Y)=i=1kYilogY^i
在这里插入图片描述

注意这里,(Y) 通常是一个独热编码(one-hot encoded)的向量,其中只有一个元素为1(表示真实的类别),其余元素为0。因此,在实际计算中,由于除了真实类别对应的 (Y_i) 为1外,其余 (Y_i) 都为0,所以求和式中实际上只有一项是有效的。

2、独热编码问题

one-hot介绍
在这里插入图片描述

五、语言模型初步理解

1、语言模型的概念

  • 语言模型(language model)是自然语言处理的重要技术。自然语言处理中最常见的数据是文本数据。可以把一段自然语言文本看作一段离散的时间序列。假设一段长度为 T T T的文本中的词依次为 w 1 , w 2 , … , w T w_1, w_2, \ldots, w_T w1,w2,,wT,那么在离散的时间序列中, w t w_t wt 1 ≤ t ≤ T 1 \leq t \leq T 1tT)可看作在时间步(time step) t t t的输出或标签。给定一个长度为 T T T的词的序列 w 1 , w 2 , … , w T w_1, w_2, \ldots, w_T w1,w2,,wT,语言模型将计算该序列的概率:

P ( w 1 , w 2 , … , w T ) . P(w_1, w_2, \ldots, w_T). P(w1,w2,,wT).

2、语言模型的计算

  • 假设序列 w 1 , w 2 , … , w T w_1, w_2, \ldots, w_T w1,w2,,wT中的每个词是依次生成的,我们有

P ( w 1 , w 2 , … , w T ) = ∏ t = 1 T P ( w t ∣ w 1 , … , w t − 1 ) . P(w_1, w_2, \ldots, w_T) = \prod_{t=1}^T P(w_t \mid w_1, \ldots, w_{t-1}). P(w1,w2,,wT)=t=1TP(wtw1,,wt1).

例如,一段含有4个词的文本序列的概率

P ( w 1 , w 2 , w 3 , w 4 ) = P ( w 1 ) P ( w 2 ∣ w 1 ) P ( w 3 ∣ w 1 , w 2 ) P ( w 4 ∣ w 1 , w 2 , w 3 ) . P(w_1, w_2, w_3, w_4) = P(w_1) P(w_2 \mid w_1) P(w_3 \mid w_1, w_2) P(w_4 \mid w_1, w_2, w_3). P(w1,w2,w3,w4)=P(w1)P(w2w1)P(w3w1,w2)P(w4w1,w2,w3).

  • 为了计算语言模型,我们需要计算词的概率,以及一个词在给定前几个词的情况下的条件概率,即语言模型参数。设训练数据集为一个大型文本语料库,如维基百科的所有条目。词的概率可以通过该词在训练数据集中的相对词频来计算。例如, P ( w 1 ) P(w_1) P(w1)可以计算为 w 1 w_1 w1在训练数据集中的词频(词出现的次数)与训练数据集的总词数之比。因此,根据条件概率定义,一个词在给定前几个词的情况下的条件概率也可以通过训练数据集中的相对词频计算。例如, P ( w 2 ∣ w 1 ) P(w_2 \mid w_1) P(w2w1)可以计算为 w 1 , w 2 w_1, w_2 w1,w2两词相邻的频率与 w 1 w_1 w1词频的比值,因为该比值即 P ( w 1 , w 2 ) P(w_1, w_2) P(w1,w2) P ( w 1 ) P(w_1) P(w1)之比;而 P ( w 3 ∣ w 1 , w 2 ) P(w_3 \mid w_1, w_2) P(w3w1,w2)同理可以计算为 w 1 w_1 w1 w 2 w_2 w2 w 3 w_3 w3三词相邻的频率与 w 1 w_1 w1 w 2 w_2 w2两词相邻的频率的比值。以此类推。

3、 n n n元语法

  • 当序列长度增加时,计算和存储多个词共同出现的概率的复杂度会呈指数级增加。 n n n元语法通过马尔可夫假设(虽然并不一定成立)简化了语言模型的计算。这里的马尔可夫假设是指一个词的出现只与前面 n n n个词相关,即 n n n阶马尔可夫链(Markov chain of order n n n)。如果 n = 1 n=1 n=1,那么有 P ( w 3 ∣ w 1 , w 2 ) = P ( w 3 ∣ w 2 ) P(w_3 \mid w_1, w_2) = P(w_3 \mid w_2) P(w3w1,w2)=P(w3w2)。如果基于 n − 1 n-1 n1阶马尔可夫链,我们可以将语言模型改写为

P ( w 1 , w 2 , … , w T ) ≈ ∏ t = 1 T P ( w t ∣ w t − ( n − 1 ) , … , w t − 1 ) . P(w_1, w_2, \ldots, w_T) \approx \prod_{t=1}^T P(w_t \mid w_{t-(n-1)}, \ldots, w_{t-1}) . P(w1,w2,,wT)t=1TP(wtwt(n1),,wt1).

以上也叫 n n n元语法( n n n-grams)。它是基于 n − 1 n - 1 n1阶马尔可夫链的概率语言模型。当 n n n分别为1、2和3时,我们将其分别称作一元语法(unigram)、二元语法(bigram)和三元语法(trigram)。例如,长度为4的序列 w 1 , w 2 , w 3 , w 4 w_1, w_2, w_3, w_4 w1,w2,w3,w4在一元语法、二元语法和三元语法中的概率分别为

P ( w 1 , w 2 , w 3 , w 4 ) = P ( w 1 ) P ( w 2 ) P ( w 3 ) P ( w 4 ) , P ( w 1 , w 2 , w 3 , w 4 ) = P ( w 1 ) P ( w 2 ∣ w 1 ) P ( w 3 ∣ w 2 ) P ( w 4 ∣ w 3 ) , P ( w 1 , w 2 , w 3 , w 4 ) = P ( w 1 ) P ( w 2 ∣ w 1 ) P ( w 3 ∣ w 1 , w 2 ) P ( w 4 ∣ w 2 , w 3 ) . \begin{aligned} P(w_1, w_2, w_3, w_4) &= P(w_1) P(w_2) P(w_3) P(w_4) ,\\ P(w_1, w_2, w_3, w_4) &= P(w_1) P(w_2 \mid w_1) P(w_3 \mid w_2) P(w_4 \mid w_3) ,\\ P(w_1, w_2, w_3, w_4) &= P(w_1) P(w_2 \mid w_1) P(w_3 \mid w_1, w_2) P(w_4 \mid w_2, w_3) . \end{aligned} P(w1,w2,w3,w4)P(w1,w2,w3,w4)P(w1,w2,w3,w4)=P(w1)P(w2)P(w3)P(w4),=P(w1)P(w2w1)P(w3w2)P(w4w3),=P(w1)P(w2w1)P(w3w1,w2)P(w4w2,w3).

n n n较小时, n n n元语法往往并不准确。例如,在一元语法中,由三个词组成的句子“你走先”和“你先走”的概率是一样的。然而,当 n n n较大时, n n n元语法需要计算并存储大量的词频和多词相邻频率。

六、论文复现准备工作

1、简易实现小项目代码地址

Github

https://github.com/aqlzh/Artificial-intelligence

在这里插入图片描述

2、简易实现小项目运行过程

在这里插入图片描述

3、抑郁症数据预处理运行过程

在这里插入图片描述


def get_files(path):
    file_info = os.walk(path)
    file_list = []
    for r, d, f in file_info:
        file_list += f
    return file_list


def get_dirs(path):
    file_info = os.walk(path)
    dirs = []
    for d, r, f in file_info:
        dirs.append(d)
    return dirs[1:]


def generate_label_file():
    print('get label....')
    base_url = './AVEC2014/label/DepressionLabels/'
    file_list = get_files(base_url)
    labels = []
    loader = tqdm(file_list)
    for file in loader:
        label = pd.read_csv(base_url + file, header=None)
        labels.append([file[:file.find('_Depression.csv')], label[0][0]])
        loader.set_description('file:{}'.format(file))
    pd.DataFrame(labels, columns=['file', 'label']).to_csv('./processed/label.csv', index=False)
    return labels


def generate_img(path, v_type, img_path):
    videos = get_files(path)
    loader = tqdm(videos)
    for video in loader:
        name = video[:5]
        save_path = img_path + v_type + '/' + name
        os.makedirs(save_path, exist_ok=True)
        cap = cv2.VideoCapture(path + video)
        n_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
        gap = int(n_frames / 100)
        for i in range(n_frames):
            success, frame = cap.read()
            if success and i % gap == 0:
                cv2.imwrite(save_path + '/{}.jpg'.format(int(i / gap)), frame, [int(cv2.IMWRITE_JPEG_QUALITY), 100])
                loader.set_description("data:{} type:{} video:{} frame:{}".format(path.split('/')[2], v_type, name, i))
        cap.release()


def get_img():
    print('get video frames....')
    train_f = './AVEC2014/train/Freeform/'
    train_n = './AVEC2014/train/Northwind/'
    test_f = './AVEC2014/test/Freeform/'
    test_n = './AVEC2014/test/Northwind/'
    validate_f = './AVEC2014/dev/Freeform/'
    validate_n = './AVEC2014/dev/Northwind/'
    dirs = [train_f, train_n, test_f, test_n, validate_f, validate_n]
    types = ['Freeform', 'Northwind', 'Freeform', 'Northwind', 'Freeform', 'Northwind']
    img_path = ['./img/train/', './img/train/', './img/test/', './img/test/', './img/validate/', './img/validate/']
    os.makedirs('./img/train', exist_ok=True)
    os.makedirs('./img/test', exist_ok=True)
    os.makedirs('./img/validate', exist_ok=True)
    for i in range(6):
        generate_img(dirs[i], types[i], img_path[i])


def get_face():
    print('get frame faces....')
    detector = MTCNN()
    save_path = ['./processed/train/Freeform/', './processed/train/Northwind/', './processed/test/Freeform/',
                 './processed/test/Northwind/', './processed/validate/Freeform/', './processed/validate/Northwind/']
    paths = ['./img/train/Freeform/', './img/train/Northwind/', './img/test/Freeform/', './img/test/Northwind/',
             './img/validate/Freeform/', './img/validate/Northwind/']
    for index, path in enumerate(paths):
        dirs = get_dirs(path)
        loader = tqdm(dirs)
        for d in loader:
            os.makedirs(save_path[index] + d.split('/')[-1], exist_ok=True)
            files = get_files(d)
            for file in files:
                img_path = d + '/' + file
                s_path = save_path[index] + d.split('/')[-1] + '/' + file
                img = cv2.cvtColor(cv2.imread(img_path), cv2.COLOR_BGR2RGB)
                info = detector.detect_faces(img)
                if (len(info) > 0):
                    x, y, width, height = info[0]['box']
                    confidence = info[0]['confidence']
                    b, g, r = cv2.split(img)
                    img = cv2.merge([r, g, b])
                    img = img[y:y + height, x:x + width, :]
                    cv2.imwrite(s_path, img, [int(cv2.IMWRITE_JPEG_QUALITY), 100])
                    loader.set_description('confidence:{:4f} img:{}'.format(confidence, img_path))


if __name__ == '__main__':
    os.makedirs('./img', exist_ok=True)
    os.makedirs('./processed', exist_ok=True)
    os.makedirs('./processed/train', exist_ok=True)
    os.makedirs('./processed/test', exist_ok=True)
    os.makedirs('./processed/validate', exist_ok=True)
    label = generate_label_file()
    get_img()
    get_face()

数据预处理时间最长的一集 😢😢

预处理有两步骤

  • 第一步是从视频中提取图片(抽取视频帧,每个视频按间隔抽取100-105帧)
  • 第二步是从图片中提取人脸信息(使用MTCNN提取人脸,并分割图片)
    在这里插入图片描述

预处理数据成功,结果如下(跑了一整个晚上)😵😵

在这里插入图片描述

4、抑郁症数据训练运行过程

电脑配置感觉跟不上了,跑不动了,epoch 0 都跑了大半天😱😱

在这里插入图片描述

七、遇到问题及其解决方案

1、pycharm 不能使用GPU加速训练

https://blog.csdn.net/QuantumYou/article/details/139215013?spm=1001.2014.3001.5501

在这里插入图片描述

2、google.protobuf.internal冲突问题

https://blog.csdn.net/QuantumYou/article/details/139212458?spm=1001.2014.3001.5501

在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/669129.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

神经网络的工程基础(二)——随机梯度下降法|文末送书

相关说明 这篇文章的大部分内容参考自我的新书《解构大语言模型:从线性回归到通用人工智能》,欢迎有兴趣的读者多多支持。 本文涉及到的代码链接如下:regression2chatgpt/ch06_optimizer/stochastic_gradient_descent.ipynb 本文将讨论利用…

Linux下CPU1000%记一次挖矿病毒清理流程

今天top后发现一个进程CPU高1795%,判断是病毒 查找进程ps -elf|grep 进程idpid和ppid查找到sleep进程 ps -ef|grep 4277 查看具体进程内容,ll /proc/进程idpid ll /proc/4277 ls -l /proc/{pid号} ls -l /proc/{pid号}/exe kill掉病毒进程 排查病毒…

Android开机动画的结束过程BootAnimation(基于Android10.0.0-r41)

文章目录 Android 开机动画的结束过程BootAnimation(基于Android10.0.0-r41) Android 开机动画的结束过程BootAnimation(基于Android10.0.0-r41) 路径frameworks/base/cmds/bootanimation/bootanimation_main.cpp init进程把我们的BootAnimation的二进制文件拉起来了&#xf…

如何备份RDK X3(旭日X3派)的 SD卡镜像

该方法可以在Ubuntu的开发机上生成一个img镜像,后续可以直接使用rufus软件烧录备份好的镜像。 Step 1:在Ubuntu的开发机上安装gparted软件 如果安装失败则需要为您的Ubuntu开发机换源,这里推荐阿里源:https://developer.aliyun.…

用户购物性别模型标签(USG)之决策树模型

一、USG模型引入: 首先了解一下,如何通过大数据来确定用户的真实性别, 经常谈论的用户精细化运营,到底是什么? 简单来讲,就是将网站的每个用户标签化,制作一个属于用户自己的网络身份证。然后,运营人员 通…

【算法】贪心算法简介

贪心算法概述 目录 1.贪心算法概念2.贪心算法特点3.贪心算法学习 1.贪心算法概念 贪心算法是一种 “思想” ,即解决问题时从 “局部最优” 从而达到 “全局最优” 的效果。 ①把解决问题的过程分为若干步②解决每一步时候,都选择当前最优解(不关注全局…

基于SSM前后端分离版本的论坛系统-自动化测试

目录 前言 一、测试环境 二、环境部署 三、测试用例 四、执行测试 4.1、公共类设计 创建浏览器驱动对象 测试套件 释放驱动类 4.2、功能测试 注册页面 登录页面 版块 帖子 用户个人中心页 站内信 4.3、界面测试 注册页面 登录页面 版块 帖子 用户个人中心页…

数据整理操作及众所周知【数据分析】

各位大佬好 ,这里是阿川的博客,祝您变得更强 个人主页:在线OJ的阿川 大佬的支持和鼓励,将是我成长路上最大的动力 阿川水平有限,如有错误,欢迎大佬指正 Python 初阶 Python–语言基础与由来介绍 Python–…

进程与线程(二)

进程与线程(二) exec函数族守护进程守护进程的概念Linux守护进程的编写步骤创建子进程,父进程退出在子进程中创建新会话改变当前目录为根目录重设文件权限掩码关闭文件描述符守护进程案例编写 线程线程的概念Linux下进程和线程的区别 Linux下…

C++基础编程100题-002 OpenJudge-1.1-04 输出保留3位小数的浮点数

更多资源请关注纽扣编程微信公众号 002 OpenJudge-1.1-04 输出保留3位小数的浮点数 http://noi.openjudge.cn/ch0101/04/ 描述 读入一个单精度浮点数,保留3位小数输出这个浮点数。 输入 只有一行,一个单精度浮点数。 输出 也只有一行,…

java —— 集合

一、集合的概念 集合可以看做是一个存储对象的容器,与数组不同的是集合可以存储不同类型的对象,但开发中一般不这样做。集合不能存储基本类型的对象,如果存储则需要将其转化为对应的包装类。 二、集合的分类 集合分为 Collection 和 Map 两…

2024抖音流量认知课:掌握流量底层逻辑,明白应该选择什么赛道 (43节课)

课程下载:https://download.csdn.net/download/m0_66047725/89360865 更多资源下载:关注我。 课程目录 01序言:拍前请看.mp4 02抖音建模逻辑1.mp4 03抖音标签逻辑2.mp4 04抖音推流逻辑3.mp4 05抖音起号逻辑4.mp4 06养号的意义.mp4 0…

算法解析——单身狗问题

欢迎来到博主的专栏:算法解析 博主ID代码小豪 文章目录 什么是单身狗问题leetcode_136——只出现一次的数字I使用位运算解决单身狗问题。 leetcode_137——只出现一次的数字II统计二进制数解决单身狗问题leetcode_260 只出现一次数字III分区域按位异或解决问题。 总…

iperf3带宽压测工具使用

iperf3带宽压测工具使用 安装下载地址:[下载入口](https://iperf.fr/iperf-download.php)测试结果:时长测试(压测使用):并行测试反向测试UDP 带宽测试 iPerf3 是用于主动测试 IP 网络上最大可用带宽的工具 安装 下载地址&#x…

SAP 生产订单批量报工(代码分享)

最近公司一直在对成本这块的业务进行梳理,影响比较大的就是生产这块的报工,经常会要求要批量的冲销报工,然后在继续报工,来调整生产订单的实际工时,前面的博客中已经给大家分享了批量冲销生产订单的代码, 下面给大家分享一下生产订单批量报工的代码 首先流程制造和离散制…

如何解决研发数据传输层面安全可控、可追溯的共性需求?

研发数据在企业内部跨网文件交换,是相对较为普遍而频繁的文件流转需求,基于国家法律法规要求及自身安全管理需要,许多企业进行内部网络隔离。不同企业隔离方案各不相同,比如银行内部将网络隔离为生产网、办公网、DMZ区&#xff0c…

如何用ChatGPT上热门:完整使用教程与写作技巧

1. ChatGPT概述修订 ChatGPT是一款基于深度神经网络的语言生成技术,能够协助用户创造出各类高品质的文字材料,适宜广泛的应用场景,如编撰文章、文学创作及社交媒体内容生成。 2. 利用ChatGPT生成热门内容的基本步骤 为了有效利用ChatGPT创作…

代码随想录算法训练营第三十五 | ● 860.柠檬水找零 ● 406.根据身高重建队列 ● 452. 用最少数量的箭引爆气球

860.柠檬水找零 讲解链接:https://programmercarl.com/0860.%E6%9F%A0%E6%AA%AC%E6%B0%B4%E6%89%BE%E9%9B%B6.html 本题只有5元10元20元,只需要考虑收到5、10、20这三种情况; 收到5元,五块的个数; 收到10,找…

Appium安装及配置(Windows环境)

在做app相关自动化测试,需要使用appium来做中转操作,下面来介绍一下appium的环境安装配置 appium官方文档:欢迎 - Appium Documentation 一、下载appium 下载地址:https://github.com/appium/appium-desktop/releases?page3 通…

Java多线程--volatile关键字

并发编程的三大特性 可见性有序性原子性 可见性 为什么会有可见性问题? 多核CPU 为了提升CPU效率,设计了L1,L2,L3三级缓存,如图。 如果俩个核几乎同时操作同一块内存,cpu1修改完,当下是对c…