【李宏毅】深度学习——HW4-Speaker Identification

Speaker Identification

1.Goal

根据给定的语音内容,识别出说话者是谁

2.Data formats

2.1data directory

目录下有三个json文件和很多pt文件,三个json文件作用标注在下图中,pt文件就是语音内容。
在这里插入图片描述

mapping文件
在这里插入图片描述

metadata文件
n_mels:The demission of mel-spectrogram(特征数是40)
speakers: A dictionary

  • key: speaker id
  • value: feature_path and mel_len
    可以发现,pt文件内容长度不一样,所以后期需要我们自己统一长度
    在这里插入图片描述

testdata文件
在这里插入图片描述

3.DataSet

构建自己的Dataset类,需要知道数据集的地址,由于每个数据长度不一样,所以还要规定数据的长度,返回值应该是,语音数据和对应的speaker的label

Dataset有三个重要的方法需要重写

  • __init__(): 初始化,一般用于读取给定的数据到内存,在该任务中,需要从给定的路径中,读取语音path和label到data数组,读取mapping将speaker的id映射为对应序号。
  • __getitem__(): 该方法根据传入的参数返回指定id的数据,在该任务中,对于传入的id,我们从data数组取出path和label,并将指定path的语音数据读出后分割,最后返回语音片段和对应的label。
  • __len__(): 该方法返回数据集的长度,在该任务中,数据集的长度即data数组的长度。

代码如下:

import os
import json
import torch
import random
from pathlib import Path
from torch.nn.utils.rnn import pad_sequence
from torch.utils.data import Dataset


class myDataset(Dataset):
    def __init__(self, data_dir, segment_len=128):
        self.data_dir = data_dir
        self.segment_len = segment_len

        # Load the mapping from speaker neme to their corresponding id.
        mapping_path = Path(data_dir) / "mapping.json"
        mapping = json.load(mapping_path.open())
        self.speaker2id = mapping["speaker2id"] # 在mapping.json 文件中 字典的key是speaker2id

        # Load metadata of training data.
        metadata_path = Path(data_dir) / "metadata.json"
        metadata = json.load(open(metadata_path))["speakers"]

        # get the total number of speaker
        self.speaker_num = len(metadata.keys())
        self.data = []
        for speaker in metadata.keys():
            for utterance in metadata[speaker]:
                self.data.append([utterance["feature_path"], self.speaker2id
                                  [speaker]])

    def __len__(self):
        return len(self.data)

    def __getitem__(self, index):
        feature_path, speaker = self.data[index]
        # Load preprocessed mel-spectrogram.
        mel = torch.load(os.path.join(self.data_dir, feature_path))

        # segment mel-spectrogram into "segment_len" frames.
        if len(mel) >self.segment_len:
            start = random.randint(0, len(mel)-self.segment_len) #随便选取一个开始截取的位置 这个位置往后的长度要大于segment_len
            mel = torch.FloatTensor(mel[start:start+self.segment_len])
        else:
            mel = torch.FloatTensor(mel)

        # Turn the speaker id into long for computing loss later.
        speaker = torch.FloatTensor([speaker]).long

        return mel, speaker

    def get_speaker_number(self):
        return self.speaker_num

最后的数据中,发言人一共600个,语音一共69438个

4.DataLoader

DataLoader的完整参数列表

class torch.utils.data.DataLoader(
dataset,
batch_size=1,
shuffle=False,
sampler=None,
batch_sampler=None,
num_workers=0,
collate_fn=<function default_collate>,
pin_memory=False,
drop_last=False,
timeout=0,
worker_init_fn=None)

其中有一个参数collate_fn,可能比较陌生
collate_fn作用
在最后一步堆叠的时候可能会出现问题: 如果一条数据中所含有的每个数据元的长度不同, 那么将无法进行堆叠. 如: multi-hot类型的数据, 序列数据。在使用这些数据时, 通常需要先进行长度上的补齐, 再进行堆叠. 以现在的流程, 是没有办法加入该操作的。此外, 某些优化方法是要对一个batch的数据进行操作。

collate_fn函数就是手动将抽取出的样本堆叠起来的函数。

所以我们需要自己定义collate_fn函数来统一特征大小

def collate_batch(batch):
    # Process features within a batch
    mel, speaker = zip(*batch)
    # Because we train the model batch by batch, we need to pad the features in the same batch to make their lengths the same
    mel = pad_sequence(mel, batch_first=True, padding_value=-20) # pad long 10^(-20) ehich is small value.
    # mel: (batch size, length, 40)
    return mel, torch.FloatTensor(speaker).long()

然后定义自己的dataloader,并在DataLoader中划分训练集和验证集

def get_dataloader(data_dir, batch_size, n_workers):
    dataset = myDataset(data_dir)
    speaker_num = dataset.get_speaker_number()
    # split
    trainlen = int(0.9 * len(dataset))
    lengths = [trainlen, len(dataset) - trainlen]
    trainset, validset = random_split(dataset, lengths)
    train_loader = DataLoader(
        trainset,
        batch_size=batch_size,
        shuffle=True,
        num_workers=n_workers,
        drop_last=True,
        pin_memory=True,
        collate_fn=collate_batch,
    )
    valid_loader = DataLoader(
        validset,
        batch_size=batch_size,
        num_workers=n_workers,
        drop_last=True,
        pin_memory=True,
        collate_fn=collate_batch,
    )
    return train_loader, valid_loader

5.Define Model

分类器是由transformerEncoder和全连接层构成的,输入是mels(shape为[batch size, length, 40]),输出是out(shape为[batch size, length, d_model])

# -*- coding = utf-8 -*-
# @Time : 2023/4/7 14:44
# @Author : 头发没了还会再长
# @File : mdoel.py
# @Software : PyCharm
import torch
import torch.nn as nn
import torch.nn.functional as F
# 分类器 使用transformer
class Classifier(nn.Module):
    def __init__(self, d_model=80, n_spks=600, dropout=0.1):
        super().__init__()
        # project the dimession of features from that of input into d_model
        self.prenet = nn.Linear(40, d_model)
        self.encoder_layer = nn.TransformerEncoderLayer(
            d_model=d_model, dim_feadforeard=256, nhead=2
        )
        self.pred_layer = nn.Sequential(
            nn.Linear(d_model, d_model),
            nn.ReLU(),
            nn.Linear(d_model, n_spks),
        )

    def forward(self, mels):
        '''
        :param mels: (batch size, length, 40)
        :return: (batch size, length, d_model)
        '''
        out = self.prenet(mels)
        out = out.permute(1, 0, 2)
        out = self.encoder_layer(out)
        out = out.transpose(0, 1)
        stats = out.mean(dim=1)
        out = self.pred_layer(stats)
        return out

6.Train and Valid

6.1 learning rate schedule

The warmup schedule

  • Set learning rate to 0 in the beginning
  • The learning rate increases linearly from 0 to initial learning rate during warmup period
import math

import torch
from torch.optim import Optimizer
from torch.optim.lr_scheduler import LambdaLR


def get_cosine_schedule_with_warmup(
  optimizer: Optimizer,
  num_warmup_steps: int,
  num_training_steps: int,
  num_cycles: float = 0.5,
  last_epoch: int = -1,
):
  """
  Create a schedule with a learning rate that decreases following the values of the cosine function between the
  initial lr set in the optimizer to 0, after a warmup period during which it increases linearly between 0 and the
  initial lr set in the optimizer.

  Args:
    optimizer (:class:`~torch.optim.Optimizer`):
      The optimizer for which to schedule the learning rate.
    num_warmup_steps (:obj:`int`):
      The number of steps for the warmup phase.
    num_training_steps (:obj:`int`):
      The total number of training steps.
    num_cycles (:obj:`float`, `optional`, defaults to 0.5):
      The number of waves in the cosine schedule (the defaults is to just decrease from the max value to 0
      following a half-cosine).
    last_epoch (:obj:`int`, `optional`, defaults to -1):
      The index of the last epoch when resuming training.

  Return:
    :obj:`torch.optim.lr_scheduler.LambdaLR` with the appropriate schedule.
  """

  def lr_lambda(current_step):
    # Warmup
    if current_step < num_warmup_steps:
      return float(current_step) / float(max(1, num_warmup_steps))
    # decadence
    progress = float(current_step - num_warmup_steps) / float(
      max(1, num_training_steps - num_warmup_steps)
    )
    return max(
      0.0, 0.5 * (1.0 + math.cos(math.pi * float(num_cycles) * 2.0 * progress))
    )

  return LambdaLR(optimizer, lr_lambda, last_epoch)

6.2定义model_fn

输入一组batch,输出损失和准确率

def model_fn(batch, model, criterion, device):
    mels, labels = batch
    mels = mels.to(device)
    labels = labels.to(device)

    outs = model(mels)
    loss = criterion(outs, labels)

    preds = outs.argmax(1)
    accuracy = torch.mean((preds == labels).float())
    return loss, accuracy

6.3 validation

def valid(dataloader, model, criterion, device): 
  """Validate on validation set."""

  model.eval()
  running_loss = 0.0
  running_accuracy = 0.0
  pbar = tqdm(total=len(dataloader.dataset), ncols=0, desc="Valid", unit=" uttr")

  for i, batch in enumerate(dataloader):
    with torch.no_grad():
      loss, accuracy = model_fn(batch, model, criterion, device)
      running_loss += loss.item()
      running_accuracy += accuracy.item()

    pbar.update(dataloader.batch_size)
    pbar.set_postfix(
      loss=f"{running_loss / (i+1):.2f}",
      accuracy=f"{running_accuracy / (i+1):.2f}",
    )

  pbar.close()
  model.train()

  return running_accuracy / len(dataloader)

6.4 有了前期的准备,就可以开始训练模型了

  • 首先,需要准备训练数据,即加载dataloader,定义损失函数,优化器等
  • 然后开始循环,在训练集上计算梯度反向传播,在验证集上计算准确率
  • 存储最优的模型
def parse_args():
  """arguments"""
  config = {
    "data_dir": "./Dataset",
    "save_path": "model.ckpt",
    "batch_size": 32,
    "n_workers": 8,
    "valid_steps": 2000,
    "warmup_steps": 1000,
    "save_steps": 10000,
    "total_steps": 70000,
  }

  return config


def main(
  data_dir,
  save_path,
  batch_size,
  n_workers,
  valid_steps,
  warmup_steps,
  total_steps,
  save_steps,
):
  """Main function."""
  device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  print(f"[Info]: Use {device} now!")

  train_loader, valid_loader, speaker_num = get_dataloader(data_dir, batch_size, n_workers)
  train_iterator = iter(train_loader)
  print(f"[Info]: Finish loading data!",flush = True)

  model = Classifier(n_spks=speaker_num).to(device)
  criterion = nn.CrossEntropyLoss()
  optimizer = AdamW(model.parameters(), lr=1e-3)
  scheduler = get_cosine_schedule_with_warmup(optimizer, warmup_steps, total_steps)
  print(f"[Info]: Finish creating model!",flush = True)

  best_accuracy = -1.0
  best_state_dict = None

  pbar = tqdm(total=valid_steps, ncols=0, desc="Train", unit=" step")

  for step in range(total_steps):
    # Get data
    try:
      batch = next(train_iterator)
    except StopIteration:
      train_iterator = iter(train_loader)
      batch = next(train_iterator)

    loss, accuracy = model_fn(batch, model, criterion, device)
    batch_loss = loss.item()
    batch_accuracy = accuracy.item()

    # Updata model
    loss.backward()
    optimizer.step()
    scheduler.step()
    optimizer.zero_grad()
    
    # Log
    pbar.update()
    pbar.set_postfix(
      loss=f"{batch_loss:.2f}",
      accuracy=f"{batch_accuracy:.2f}",
      step=step + 1,
    )

    # Do validation
    if (step + 1) % valid_steps == 0:
      pbar.close()

      valid_accuracy = valid(valid_loader, model, criterion, device)

      # keep the best model
      if valid_accuracy > best_accuracy:
        best_accuracy = valid_accuracy
        best_state_dict = model.state_dict()

      pbar = tqdm(total=valid_steps, ncols=0, desc="Train", unit=" step")

    # Save the best model so far.
    if (step + 1) % save_steps == 0 and best_state_dict is not None:
      torch.save(best_state_dict, save_path)
      pbar.write(f"Step {step + 1}, best model saved. (accuracy={best_accuracy:.4f})")

  pbar.close()


if __name__ == "__main__":
  main(**parse_args())

这是训练过程中的截图:
在这里插入图片描述

7.Test

训练完模型,我们会得到最好的参数,并且保存在model.ckpt文件中了,接下来,只需要定义训练的函数,使用保存的最优模型开始训练即可。
测试和训练基本相同,需要准备dataset,dataloader

7.1 Inference dataset

class InferenceDataset(Dataset):
    def __init__(self, data_dir):
        testdata_path = Path(data_dir)
        metadata = json.load(testdata_path.open())
        self.data_dir = data_dir
        self.data = metadata["utterances"]

    def __len__(self):
        return len(self.data)

    def __getitem__(self, index):
        utterance = self.data[index]
        feature_path = utterance["feature_path"]
        mel = torch.load(os.path.join(self.data_dir, feature_path))

        return feature_path, mel

7.2可以开始预测啦

def inference_collate_batch(batch):
    feature_paths, mels = zip(*batch)
    return feature_paths, torch.stack(mels)

def parse_args():
  """arguments"""
  config = {
    "data_dir": "dataset",
    "model_path": "./model.ckpt",
    "output_path": "./output.csv",
  }

  return config

def main(data_dir,model_path,output_path,):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    print(f"[Info]: Use {device} now!")

    mapping_path = Path(data_dir) / "mapping.json"
    mapping = json.load(mapping_path.open())

    dataset = InferenceDataset(data_dir)
    dataloader = DataLoader(
        dataset,
        batch_size=1,
        shuffle=False,
        drop_last=False,
        num_workers=0,
        collate_fn=inference_collate_batch,
    )
    print(f"[Info]: Finish loading data!", flush=True)

    speaker_num = len(mapping["id2speaker"])
    model = Classifier(n_spks=speaker_num).to(device)
    model.load_state_dict(torch.load(model_path))
    model.eval()
    print(f"[Info]: Finish creating model!", flush=True)
    results = [["Id", "Category"]]
    for feat_paths, mels in tqdm(dataloader):
        with torch.no_grad():
            mels = mels.to(device)
            outs = model(mels)
            preds = outs.argmax(1).cpu().numpy()
            for feat_path, pred in zip(feat_paths, preds):
                results.append([feat_path, mapping["id2speaker"][str(pred)]])

    with open(output_path, 'w', newline='') as csvfile:
        writer = csv.writer(csvfile)
        writer.writerows(results)

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

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

相关文章

飞桨EasyDL落地三大工业场景,工业AI赋能产业升级

数智化时代&#xff0c;如何利用人工智能实现传统生产方式的转型升级&#xff0c;成为摆在每个工业制造企业的一道必答题。工业生产、质检、管理等环节&#xff0c;持续产生海量数据。以机器视觉为代表的AI技术&#xff0c;广泛应用在3C电子、快消品制造、汽车零部件制造等多个…

指令系统和寻址方式

文章目录指令系统指令的基本格式扩展码指令格式指令的操作类型指令的寻址方式指令寻址数据寻址隐含寻址立即寻址直接寻址间接寻址寄存器寻址寄存器间接寻址相对寻址基址寻址变址寻址堆栈寻址使用场景PSW小结程序的机器级代码表示CISC和RISC刷题小结指令系统 指令&#xff1a;计…

Revit插件 | 建模助手2023年度版本大更新,就是这么懂你

​大家好&#xff0c;本期是懂你的建模助手。 从去年开始&#xff0c;建模助手几乎每个月都会有大大小小的活动&#xff0c;目的是让大家用最低的成本尝试极棒的建模体验&#xff01;强行挽尊ing 但作为一支很pro的团队&#xff0c;单一地搞活动肯定不行滴&#xff0c;还得在…

Python SMTP发送邮件和线程

文章目录一、Python SMTP发送邮件二、Python3 多线程总结一、Python SMTP发送邮件 SMTP&#xff08;Simple Mail Transfer Protocol&#xff09;即简单邮件传输协议,它是一组用于由源地址到目的地址传送邮件的规则&#xff0c;由它来控制信件的中转方式。 python的smtplib提供…

使用ChatGPT帮助我们编码的10种场景

文章目录1、技术搜索2、生成常用工具函数3、帮助解读代码4、添加注释5、优化代码6、Vue2 转 Vue37、Vue 转 React8、补充 TypeScript 类型9、生成文档10、工具配置总结ChatGPT 的出现&#xff0c;彻底改变的很多代码开发的方式&#xff0c;特别是通用型的代码&#xff0c;使用它…

基于公私密钥的单点登录

目前已知的单点登陆方式有&#xff1a; 多个系统集群 建立一个SSO认证中心&#xff0c;用户只需要登录一次就可以访问所有相互信任的应用系统。 1、可以通过session广播机制实现&#xff1a;在一个集群中的一个模块登录后&#xff0c;然后把这个session复制n份&#xff0c;发…

JUC-01 线程的创建和状态转换

本次我们主要讲三个问题 线程是什么&#xff1f;线程有哪些状态&#xff1f;各状态间的转换了解吗&#xff1f;创建线程的3种方法你都了解吗&#xff1f; 1. 线程是什么&#xff1f;&#xff08;了解即可&#xff09; 进程&#xff1a; 进程是一个具有一定独立功能的程序在一…

计算机网络考试复习——第一章 1.7

1.7 计算机网络体系结构 两台计算机要互相传送文件需解决很多问题: (1) 必须有一条传送数据的通路。 (2) 发起方必须激活通路。 (3) 要告诉网络如何识别接收方。 (4) 发起方要清楚对方是否已开机&#xff0c;且与网络连接正常。 (5) 发起方要清楚对方是否准备好接收和存储文件…

数据结构——栈与队列相关题目

数据结构——栈与队列相关题目232. 用栈实现队列思路225. 用队列实现栈1.两个队列实现栈2.一个队列实现栈20. 有效的括号思路1047. 删除字符串中的所有相邻重复项思路155. 最小栈150. 逆波兰表达式求值思路239. 滑动窗口最大值单调队列347. 前 K 个高频元素思路232. 用栈实现队…

2023版Postman接口测试使用全指南(原来使用 Postman测试API接口如此简单)

下面是一篇详细介绍postman接口测试的文章&#xff0c;如果文章内容不太明白的话&#xff0c; 我建议看看视频版本&#xff0c;更加清洗&#xff0c;更加直观&#xff01; 最详细的postman接口测试实战教程_哔哩哔哩_bilibili最详细的postman接口测试实战教程共计129条视频&am…

ToBeWritten之ARM汇编基础铺垫

也许每个人出生的时候都以为这世界都是为他一个人而存在的&#xff0c;当他发现自己错的时候&#xff0c;他便开始长大 少走了弯路&#xff0c;也就错过了风景&#xff0c;无论如何&#xff0c;感谢经历 转移发布平台通知&#xff1a;将不再在CSDN博客发布新文章&#xff0c;敬…

FPGA解码4line MIPI视频 IMX291/IMX290摄像头采集 提供工程源码和技术支持

目录1、前言2、Xilinx官方主推的MIPI解码方案3、我已有的MIPI解码方案4、纯Vhdl代码解码MIPI5、vivado工程介绍6、上板调试验证7、福利&#xff1a;工程代码的获取1、前言 FPGA图像采集领域目前协议最复杂、技术难度最高的应该就是MIPI协议了&#xff0c;MIPI解码难度之高&…

关键词采集软件在SEO优化中的应用与效果

搜索引擎的优化被广泛认为是提高网站排名和在线可见性的重要方法之一。SEO人员需要进行大量的工作以确保网站的内容和标签可以被搜索引擎正确地解析和索引。在这项任务中&#xff0c;使用搜索引擎关键词采集软件可以帮助SEO人员完成许多繁琐的任务并简化他们的工作流程。在本文…

Linux 基础IO(Input与output)学习

进程间通信&#xff1a;讲的是操作系统为用户提供的几种进程间的通信方式概念&#xff1a;进程间通信其实就是多个进程之间进行数据交互问题&#xff1a;进程间通信为什么不能直接进行数据交互&#xff0c;需要使用系统提供的方式&#xff1f;原因&#xff1a;进程之间是具有独…

电动力学问题中的Matlab可视化

电磁场的经典描述 小说一则 电磁场的经典描述就是没有啥玩意量子力学的经典电动力学下对电磁场的描述,以后有空写个科幻小说,写啥呢,就写有天张三遇见了一个外星人,外星人来自这样一个星球,星球上的物质密度特别低,导致外星人的测量会明显的影响物质的运动,外星人不能同时得到…

JNI 调用

简介 JNI是Java Native Interface的缩写&#xff0c;通过使用 Java本地接口书写程序&#xff0c;可以确保代码在不同的平台上方便移植。从Java1.1开始&#xff0c;JNI标准成为java平台的一部分&#xff0c;它允许Java代码和其他语言写的代码进行交互。 本地代码与 Java 虚拟机…

【ChatGPT】ChatGPT-5 强到什么地步?

Yan-英杰的主页 悟已往之不谏 知来者之可追 C程序员&#xff0c;2024届电子信息研究生 目录 ChatGPT-5 强到什么地步&#xff1f; 技术 深度学习模型的升级 更好的预测能力 自适应学习能力 特点 语言理解能力更强 自我修正和优化 更广泛的应用领域 应用 对话系统 智能写作…

【机器学习】吴恩达机器学习Deeplearning.ai

机器学习已经强大到可以独立成为人工智能的一个子领域。 可以通过对机器编程实现比如执行网络搜索、理解人类语言、通过x光诊断疾病&#xff0c;或制造自动驾驶汽车。 机器学习定义 一般来说&#xff0c;给一个算法学习的机会越多&#xff0c;它的表现就越好。 机器学习的两种…

阿里云5、6代云服务器实例免费升级至第7代(不限次数)

简介&#xff1a; 阿里云推出云服务器实例免费升级至第7代优惠活动&#xff0c;第5、&#xff16;代云服务器&#xff0c;可享受实例部分免费升级至第7代实例&#xff0c;让你的云服务器拥有更高的安全、存储、网络等性能。 阿里云服务器升级有优惠吗&#xff1f;当然是有的&am…
最新文章