pytorch

https://pytorch-cn.readthedocs.io/zh/latest/

根据model计算参数数量

自己算：单层乘法，层间加法，一个卷积核就算一层，这样是8层

def count_param(model):
    param_count = 0
    layer = 0
    for param in model.parameters():
        layer += 1
        param_layer = param.view(-1).size()[0]
        param_count += param_layer
        print(f'layer - {layer} shape:{param.size()} layer amount : {param_layer} sum : {param_count}')
    print(f'The amount of parameters is {param_count} ')

输出相关

进度条tqdm

直接套在range外面就行

for epoch in tqdm(range(1,self.num_epochs+1-self.last_epoch))

日志输出

def setlogger(path):
    logger = logging.getLogger()
    logger.setLevel(logging.INFO)
    logFormatter = logging.Formatter("%(asctime)s %(message)s", "%m-%d %H:%M:%S")

    fileHandler = logging.FileHandler(path)
    fileHandler.setFormatter(logFormatter)
    logger.addHandler(fileHandler)

    consoleHandler = logging.StreamHandler()
    consoleHandler.setFormatter(logFormatter)
    logger.addHandler(consoleHandler)

参数微调

with torch.no_grad():
所有计算得出的tensor的requires_grad都自动设置为False。
就是在计算时不会更新，相当于冻结
音频输入输出：
https://librosa.org/doc/latest/ioformats.html?highlight=output
keras文档

模型保存和测试

保存
运行
测试
model.save("./model.h5")
new_model = load_model('./model.h5')
y = new_model.predict(feature)
y输出结构看fit时结构，和pytorch的区别是没有forword。
model.fit(feature, label, batch_size=128, epochs=200, validation_split=0.1)

gpu

gpu相关设置

gpu安装

dataloader

0.dataloader的迭代次数

for i, data in enumerate(self.dataloader['train_loader']):
迭代次数和就是数据集数据量/batchsize取整

epoch 与 batch 关系

一个epoch完整过一次数据集
batch：一次forward，backward用多少数据
iteration ：一次传播
iteration和batch是对应的

for epoch_i in range(start_epoch+1, end_epoch+1):
    for i,data in enumerate(rand_loader):

1.dataloader的基础使用

必要

test_data = torchvision.datasets.CIFAR10("./CIFAR10", train=False, transform=torchvision.transforms.ToTensor())
test_loader = DataLoader(dataset=test_data, batch_size=4, shuffle=True, num_workers=0, drop_last=False)

Training_data_Name = 'Training_Data.mat'
Training_data = sio.loadmat('./%s/%s' % (args.data_dir, Training_data_Name))
Training_labels = Training_data['labels']
rand_loader = DataLoader(dataset=RandomDataset(Training_labels, nrtrain), batch_size=batch_size, num_workers=0, shuffle=True)

2.dataloader中的data

继承dataset类
实现三个方法，或者迭代器方法
以下如何实现的，迭代中的data就是咋样的

def __getitem__(self, index):
    return torch.Tensor(self.data[index, :]).float()

def __iter__(self):
    return self.generator

item和iter中返回的是单个数据

但是迭代中data返回batch*单个，这一处理由dataloader实现

1.简单实现三个函数
init的参数可操作
其他两个是固定的不能变
getitem：接收一个索引， 返回一个样本

for i,data in enumerate(rand_loader):
  batch_x = data
class RandomDataset(Dataset):
    def __init__(self, data, length):
        self.data = data
        self.len = length

    def __getitem__(self, index):
        return torch.Tensor(self.data[index, :]).float()

    def __len__(self):
        return self.len
    

2.用生成器自定义迭代方法

    def get_random_batch_generator(self, Set):#'train'
    #其他处理过程
            batch = {'data_input': batch_inputs, 'condition_input': condition_inputs}, {
                'data_output_1': batch_outputs_1, 'data_output_2': batch_outputs_2}

            yield batch

class denoising_dataset(torch.utils.data.IterableDataset):
    def __init__(self, generator):
        self.generator = generator
    def __iter__(self):
        return self.generator

train_set_generator = dataset.get_random_batch_generator('train')
train_set_iterator = datasets.denoising_dataset(train_set_generator)
train_loader = DataLoader(train_set_iterator, batch_size=None)
dataloader = {'train_loader':train_loader, 'valid_loader':valid_loader}
for i, data in enumerate(self.dataloader['train_loader']):
	x, y = data

yield用法

• yield就是 return 返回一个值，并且记住这个返回的位置，下次迭代就从这个位置后开始
• 如果用getitem和列表，就是加载整个列表，再取值，用生成器函数和yield就是用一个加载一个
• 使用场景：需要逐个去获取容器内的某些数据，容器内的元素数量非常多，或者容器内的元素体积非常大
• 如果一个函数定义中包含 yield 表达式，那么该函数是一个生成器函数
• 底层实现和next函数有关data = next(self.dataset_iter)

使用yield相当于返回了一个可供迭代的列表
在函数开始处，加入 result = list()；
将每个 yield 表达式 yield expr 替换为 result.append(expr)；
在函数末尾处，加入 return result。

def get_random_batch_generator(self, Set):#'train'

    if Set not in ['train', 'test']:
        raise ValueError("Argument SET must be either 'train' or 'test'")

    while True:
        sample_indices = np.random.randint(0, len(self.sequences[Set]['clean']), self.batch_size) #btach.size:10
        condition_inputs = []
        batch_inputs = []
        batch_outputs_1 = []
        batch_outputs_2 = []

        for i, sample_i in enumerate(sample_indices):#[ 9941  5657  5610  6613  6152  2843 10611  2560  5729 10366]

            while True:

                speech = self.retrieve_sequence(Set, 'clean', sample_i) #52480
                noisy = self.retrieve_sequence(Set, 'noisy', sample_i) #52480
                noise = noisy - speech

                if self.extract_voice:
                    speech = speech[self.voice_indices[Set][sample_i][0]:self.voice_indices[Set][sample_i][1]] #shape:39200

                speech_regained = speech * self.regain_factors[Set][sample_i] #39200 20800（5657）
                noise_regained = noise * self.regain_factors[Set][sample_i]

                if len(speech_regained) < self.model.input_length:
                    sample_i = np.random.randint(0, len(self.sequences[Set]['clean']))
                else:
                    break

            offset = np.squeeze(np.random.randint(0, len(speech_regained) - self.model.input_length, 1)) #29494 7516（5610）

            speech_fragment = speech_regained[offset:offset + self.model.input_length] #shape:7739
            noise_fragment = noise_regained[offset:offset + self.model.input_length]

            Input = noise_fragment + speech_fragment #7739
            output_speech = speech_fragment #7739
            output_noise = noise_fragment

            if self.noise_only_percent > 0:
                if np.random.uniform(0, 1) <= self.noise_only_percent:
                    Input = output_noise #Noise only
                    output_speech = np.array([0] * self.model.input_length) #Silence

            batch_inputs.append(Input) #list
            batch_outputs_1.append(output_speech)
            batch_outputs_2.append(output_noise)

            if np.random.uniform(0, 1) <= 1.0 / self.get_num_condition_classes():
                condition_input = 0
            else:
                condition_input = self.speaker_mapping[self.speakers[Set][sample_i]]
                if condition_input > 28: #If speaker is in test set, use wildcard condition class 0
                    condition_input = 0

            condition_inputs.append(condition_input)

        batch_inputs = np.array(batch_inputs, dtype='float32')#array
        batch_outputs_1 = np.array(batch_outputs_1, dtype='float32')
        batch_outputs_2 = np.array(batch_outputs_2, dtype='float32')
        batch_outputs_1 = batch_outputs_1[:, self.model.get_padded_target_field_indices()]
        batch_outputs_2 = batch_outputs_2[:, self.model.get_padded_target_field_indices()]
        condition_inputs = self.condition_encode_function(np.array(condition_inputs, dtype='uint8'), self.model.num_condition_classes)

        batch = {'data_input': batch_inputs, 'condition_input': condition_inputs}, {
            'data_output_1': batch_outputs_1, 'data_output_2': batch_outputs_2}

        yield batch

复数处理

view_as_real

在最后增加一个维度,大小为2
1->1,2
1+2j->[1,2]

取实数部分

x = torch.view_as_real(x)[:,:,:,0].squeeze(-1)
x_input = x.view(-1, 1, 39, 39)

运算，转化为numpy

https://blog.csdn.net/Stephanie2014/article/details/105984274

维度处理

size不变

squeeze()只能去值为1的维度，否则不变
返回张量与输入张量共享内存，所以改变其中一个的内容会改变另一个
a.unsqueeze(x)在x维(从0开始计数，从前往后数)上增加1维
a.unsqueeze(0)
6 ->1,6
a.squeeze(x) 去掉x维，

-x dim为负，则将会被转化dim+input.dim()+1
-1就是size从前往后最后一维
6->6,1
a=squeeze(a)去掉所有值为1的维度

size变化，值复制

repeat
在对应维度上repeat几倍

 a.repeat(2,1).size()     # 原始值：torch.Size([33, 55])
torch.Size([66, 55])

condition_out = layers.expand_dims(condition_out, -1)#torch.Size([50, 128, 1])
condition_out = condition_out.repeat(1,1,self.input_length)#torch.Size([50, 128, 7739])最后维度每个值重复7739

创建同维度的0矩阵

x=torch.zeros([2,3])
y=torch.zeros(x.shape)

创建指定维度的矩阵

要用列表，不能（2,3）

x=torch.zeros([2,3])

保持数据量不变的情况下变化形状

#xw：torch.Size([128, 1089])
x_input = xw.view(-1, 1, 33, 33) #torch.Size([128, 1, 33, 33])

• 参数中的-1就代表这个位置由其他位置的数字来推断
• 正整数参数就是指定维度

某一维度的长度

x.shape[n]

传播过程

def expand_dims(x, axes):
    
    if axes == 1:
        x = x.unsqueeze_(1)
    if axes == -1:
        x = x.unsqueeze_(-1)
    return x

切片

slice()
是一个切片对象，作数组的参数，返回的是下标

对多维的单维切片

layers.slicing(data_expanded,n,  m+ 1, 1),2)
def slicing(x, slice_idx, axes):
    if axes == 1:
        return x[:,slice_idx,:]
    if axes == 2:
        return x[:,:,slice_idx]

data_out_2 = layers.slicing(data_out, slice(self.config['model']['filters']['depths']['res'], 
                                            2*self.config['model']['filters']['depths']['res'],1), 1)

拼接与求和？

data_out = torch.stack( skip_connections, dim = 0).sum(dim = 0)
stack：https://cxymm.net/article/m0_61899108/122666906

detach()？

model 323

 batch_metric.append(self.metric_fn(y['data_output_1'].detach(), y_hat[0].detach()))  

批量数据处理

items() 返回字典所有键值对
变量：操作，实际值

map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]

x = dict(map(lambda i: (i[0], i[1].to(self.device, dtype=torch.float32)), x.items()))

卷积层定义

nn.conv1d

对于输入的要求[batch_size,输入通道数，信号大小]
nn.Conv1d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

通道可以用RGB帮助理解，就是某个特定方面的信息

• inchannel:输入信号的维度，不包括batchsize

输入通道数的物理含义 对图片取决于图片类型，RGB为3，对声音就是1，对文本自定义

• out_channels：输出通道数，会影响通过该层后的输出

物理含义是过滤器(卷积核)数量（深度）

• kernel_size(int or tuple) - 卷积核的尺寸，卷积核的大小为(in_channels，size)，

横向维度是由in_channels来决定的，所以实际上卷积大小为kernel_size*in_channels
会对output产生影响的只有out_channels

• stride： 卷积步长
• bias： 如果bias=True，添加偏置

nn.conv1d只在列方向滑动，所以卷积核大小中的高维必然与inchannel保持一致

通过之后的效果

n.Conv1d(1, 128, 3,stride=1, bias = False, padding=1）
Conv1d顺序不同于参数结构顺序
in要对应输入
Conv1d ：in out kernel
卷积核：out in kernel

• input 结构 batch_size*input_channel*信号size
• 该层参数结构：output_channel * (input_channel*kernel_size)
• 输出结构：batch_size*output_channel*信号size处理后
• 在stride和pad都为1的情况下，只有output_channel会变化

nn.conv2d

在横向和竖向都移动卷积核
对输入维度的改变与conv1d没有区别
主要是 in - out
如果有pad 和 stride 则后两维也会改变

layer = nn.Conv2d(1, 3, kernel_size=3, stride=1, padding=0)

• in
• out
• kernel_size:
  • 一个数 则大小为n*n
  • 一个元组（m*n）

主体训练结构

for epoch_i in range(start_epoch+1, end_epoch+1):
for i,data in enumerate(rand_loader):
batch_x = data
batch_x = batch_x.to(device)
y_hat = self.model(x)
optimizer.zero_grad()
loss_all.backward(retain_graph=True)
optimizer.step()

loss

是一个tensor即可

loss_discrepancy = torch.mean(torch.pow(x_output - batch_x, 2))

loss_constraint = torch.mean(torch.pow(loss_layers_sym[0], 2))
for k in range(layer_num-1):
    loss_constraint += torch.mean(torch.pow(loss_layers_sym[k+1], 2))

gamma2 = torch.Tensor([0.01]).to(device)

# loss_all = loss_discrepancy
loss_all = loss_discrepancy + torch.mul(gamma2, loss_constraint)

    def get_out_1_loss(self):

        if self.config['training']['loss']['out_1']['weight'] == 0:
            return lambda y_true, y_pred: y_true * 0

        return lambda y_true, y_pred: self.config['training']['loss']['out_1']['weight'] * util.l1_l2_loss(
            y_true, y_pred, self.config['training']['loss']['out_1']['l1'],
            self.config['training']['loss']['out_1']['l2'])
            
 def get_loss_fn(self, y_hat, y):
    target_speech = y['data_output_1']
    target_noise = y['data_output_2']
    output_speech = y_hat[0]
    output_noise = y_hat[1]
    loss1 = self.out_1_loss(target_speech, output_speech)
    loss2 = self.out_2_loss(target_noise, output_noise)
    loss = loss1 + loss2
    
    return loss

optimizer

optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
optimizer = optim.Adam(self.model.parameters(), lr=self.config['optimizer']['lr'], weight_decay=self.config['optimizer']['decay'])

retain_graph

retain_graph=True，目的为是为保留该过程中计算的梯度，后续G网络更新时使用

model

model = ISTANet(layer_num)
model = nn.DataParallel(model)
model = model.to(device)

self.device = self.cuda_device()
self.model = model.to(self.device)

model = models.DenoisingWavenet(config)
class DenoisingWavenet(nn.Module):

    def __init__(self, config, input_length=None, target_field_length=None):
        super().__init__()
    def forward(self, x):

卷积操作与卷积层

使用时卷积层只需传入输入

data_out = self.conv1(data_x)
self.conv1 = nn.Conv1d(in, out,kernel_size, stride=1, bias = False, dilation = self.dilation, padding=int(self.dilation))

卷积操作需要传入输入和卷积核
卷积核是 out in size 卷积操作是in out size

torch.nn.functional.conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1)

• input
• weight : out in kernel

self.conv1_forward = nn.Parameter(init.xavier_normal_(torch.Tensor(32, 1, 3, 3)))
x = F.conv2d(x_input, self.conv1_forward, padding=1)

数据集划分

https://zhuanlan.zhihu.com/p/385229355

格式转化

torch.tensor(,dtype=)

维度转置

y1 = x.transpose()