深度学习 十四讲 循环神经网络例子--名字分类

在这里插入图片描述
任务:根据输入的不同名字,分出所属国家

模型如下
在这里插入图片描述
在这里插入图片描述
数据两列:名字,国家

实现过程

准备数据
用ASCII表作为字典长度,字典长度为128
在这里插入图片描述

实际上这个77对应的是一个one_hot向量,这个向量一共有128维,除了第77个位置为1,其余为0

在这里插入图片描述这些字符长短不一,所以做一些填充,由于输入要是一个矩阵(sqlen,batch,input)。每次做一个batch的时候,看哪一个最长,就按照最长的来填充

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

什么是双向神经网络?-- bidirectional
在这里插入图片描述

从序列反向再加上之前正向的数据,再算一次,最后拼接起来

每次调用GRU时,会输出(out,hidden)

out:
在这里插入图片描述hidden:
在这里插入图片描述
在这里插入图片描述在这里插入图片描述

在这里插入图片描述
def forward中的转置
在这里插入图片描述
在这里插入图片描述在这里插入图片描述pack_padded_sequence
但是这个打包函数必要要是由大到小的数列长度排列

在这里插入图片描述所以需要由长到短进行排列
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述这样排列,计算效率就会更加高

在这里插入图片描述转置
在这里插入图片描述转置后排序``
在这里插入图片描述

import torch
from torch.utils.data import DataLoader
from torch.utils.data import Dataset
import numpy as np
import matplotlib.pyplot as plt
import time
import math
import gzip
import csv
from torch.nn.utils.rnn import pack_padded_sequence  # 导入pack_padded_sequence()方法

'''输出共18种语言'''

'''模型主要由embedding layer, GRU和Linear layer构成'''

# parameters
NUM_CHARS = 128
HIDDEN_SIZE = 100
NUM_COUNTRIES = 18
NUM_LAYERS = 2
USE_GPU = False
NUM_EPOCHS = 100  # 本实验25个epoch就可以了
BATCH_SIZE = 256

'''1.Prepare data 构建数据集类'''


class NameDataset(Dataset):
    # 初始化
    def __init__(self, is_training_set=True):
        # super(NameDataset, self).__init__()
        # 根据是否是训练集来选择文件名
        filename = "../dataset/names_train.csv.gz" if is_training_set else "../dataset/names_test.csv.gz"
        # 用到gzip包和csv包来从.gz文件中读取data
        with gzip.open(filename, 'rt') as f:
            reader = csv.reader(f)
            rows = list(reader)  # rows列表中每一个元素都是数据集中的一行(name+country)
        # 处理name
        self.name_list = [row[0] for row in rows]  # 每一行的第0个元素是name
        self.len = len(self.name_list)  # 数据集的大小(样本的总数目)
        # 处理country
        self.orgin_country_list = [row[1] for row in rows]  # 每一行的第1个元素是country,orgin_country_list中的country是有重复的,无序的
        self.country_list = list(sorted(set(self.orgin_country_list)))  # 注意:country_list中的country没有重复,并且是有序的(字典序)
        self.country_dict = self.getCountryDict()  # 调用函数getCountryDict()获得country_dict,字典中key:country; value:index
        self.num_countries = len(self.country_dict)  # country的种类数,是输出维度

    # 根据下标获得数据集中的某一个样本信息[name+country在字典中的索引]
    def __getitem__(self, index):
        return self.name_list[index], self.country_dict[self.orgin_country_list[index]]  # 返回name字符串和country对应的字典下标

    # 获得数据集大小
    def __len__(self):
        return self.len

    # 获得country字典 (键:country, 值:字典序的下标)
    def getCountryDict(self):
        country_dict = dict()  # 初始化字典
        # 将list转化为dict
        for index, country in enumerate(self.country_list, 0):  # index从0开始
            country_dict[country] = index  # 键:country, 值:字典序的下标
        return country_dict

    # 根据字典下标获得country
    def index2country(self, index):
        return self.country_dict[index]

    # 获得数据集中country的种类数
    def getCountriesNum(self):
        return self.num_countries


# 根据tensor是否迁移到GPU上 返回tensor
def createTensor(tensor):
    if USE_GPU:
        device = torch.device("cuda:0")
        tensor = tensor.to(device)  # tensor移动到GPU上
    return tensor


'''2. Design model'''


class RNNClassifier(torch.nn.Module):
    def __init__(self, input_size, hidden_size, output_size, num_layers=1, bidirectional=True):
        super(RNNClassifier, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.num_directions = 2 if bidirectional else 1

        # embedding
        # input size: (seq_len, batch_size)
        # output size: (seq_len, batch_size, hidden_size)
        self.embedding = torch.nn.Embedding(input_size, hidden_size)
        # GRU
        # INPUTS: input size: (seq_len, batch_size, hidden_size)
        # INPUTS: hidden size: (num_layers * num_directions, batch_size, hidden_size)
        # OUTPUTS: output size: (seq_len, batch_size, hidden_size * num_directions)
        # OUTPUTS: hidden size: (num_layers * num_directions, batch_size, hidden_size)
        self.gru = torch.nn.GRU(hidden_size, hidden_size, num_layers, bidirectional=bidirectional)
        # Linear(Fully Connected layer)
        self.fc = torch.nn.Linear(hidden_size * self.num_directions, output_size)

    def initHidden(self, batch_size):
        hidden = torch.zeros(self.num_layers * self.num_directions, batch_size, self.hidden_size)
        return createTensor(hidden)

    def forward(self, input, seq_lengths):
        input = input.t()  # 将input转置 batch_size * seq_len --> seq_len * batch_size
        batch_size = input.size(1)
        hidden = self.initHidden(batch_size)  # init hidden 0

        # embedding layer
        embedding = self.embedding(input)  # embedding size: batch_size, seq_len, embedding_size

        # GRU
        gru_input = pack_padded_sequence(embedding,
                                         seq_lengths)  # pack_padded_sequence,将输入转化为size为seq_len, batch_size, hidden_size的tensor
        # 返回一个PackedSequence对象
        # 第2个参数:一个tensor, 是每个batch element的长度列表
        output, hidden = self.gru(gru_input, hidden)
        if self.num_directions == 2:
            hidden_cat = torch.cat([hidden[-1], hidden[-2]], dim=1)  # GRU为双向时,hidden = [前向的第n个hidden, 反向的第n个hidden] 连接
        else:
            hidden_cat = hidden[-1]  # GRU为单向时,hidden = 前向的第n个hidden

        # fully connected layer
        fc_output = self.fc(hidden_cat)
        return fc_output


## convert name to tensor
# 必须sort the batch element by length of sequence(降序)
# name -> characters -> ASCII值 -> padding -> (transpose) ->sort

# 将某个name转换为相应的字符对应的ASCII码值的列表  "Alice" -> ['A','l','i','c','e'] -> [65 108 105 99 101]
def name2ASCIIlist(name):
    ASCIIlist = [ord(char) for char in name]  # ord(char)获取char的ASCII码值
    return ASCIIlist


def makeTensors(name_list, country_list):
    ## 获得每个name的码值列表,然后得到所有码值列表的列表
    name_sequences = [name2ASCIIlist(name) for name in name_list]  # name -> characters_list -> ASCII值_list
    name_seq_lens = [len(name_ASCII) for name_ASCII in name_sequences]  # 每个姓名ASCII序列的长度的列表
    # 数值类型转换
    name_seq_lens = torch.LongTensor(name_seq_lens)
    country_list = country_list.long()

    ## padding   make tensor of name, BatchSize * SeqLen
    # 先构造一个(dataset.len, max(name_seq_len))大小的全0张量
    name_tensor = torch.zeros(len(name_sequences), name_seq_lens.max()).long()
    # 然后将每个name_sequence填到全0张量中
    for index, (name_sequence, name_seq_len) in enumerate(zip(name_sequences, name_seq_lens), 0):
        name_tensor[index, 0:name_seq_len] = torch.LongTensor(
            name_sequence)  # 第index行的第0列到第len(name_seq)列 填入 name_sequence

    ## sort by length of name_sequence to use pack_padded_sequence
    ordered_name_seq_lens, len_indexes = name_seq_lens.sort(dim=0,
                                                            descending=True)  # 首先将name_seq_lens降序排序,len_indexes是它在原tensor中的索引
    ordered_name_tensor = name_tensor[len_indexes]  # 按照新的下标更新name_tensor
    ordered_country_list = country_list[len_indexes]  # 同步更新country_list中的值

    ## 返回转化后的name tensor, name's length tensor and country_list tensor
    return createTensor(ordered_name_tensor), createTensor(ordered_name_seq_lens), createTensor(ordered_country_list)


'''3. Training and Test'''


def train():  # 每个epoch的训练过程
    loss = 0.0
    for batch_index, (names, countries) in enumerate(train_loader, 0):  # 每一次取出一个batch中的所有样本
        ## 对于每一个batch中的所有样本,做如下操作:
        # forward
        inputs, seq_lens, targets = makeTensors(names, countries)
        outputs = classifier_model(inputs, seq_lens)
        loss = criterion(outputs, targets)
        # backward
        optimizer.zero_grad()
        loss.backward()
        # update
        optimizer.step()

        loss += loss.item()

        if batch_index % 10 == 9:  # 每10个batch输出一次信息
            print(f'time_elapsed:{timePassed(start_time)}, Epoch {epoch}, ', end='')  # 输出经过的时间和epoch
            print(f'[{(batch_index + 1) * len(inputs)} / {len(training_set)}] ', end='')  # 已经训练过的样本数/总样本数,用来表示训练进度
            print(f'loss = {loss / ((batch_index + 1) * len(inputs))}')  # loss求均值


def test():
    correct = 0
    total_samples = len(test_set)
    print("====evaluating trained model...(is testing)")
    with torch.no_grad():
        for i, (names, countries) in enumerate(test_loader, 0):
            inputs, seq_lens, targets = makeTensors(names, countries)
            outputs = classifier_model(inputs, seq_lens)
            # country_pred = torch.max(output, dim = 1)
            country_preds = outputs.max(dim=1, keepdim=True)[1]
            # correct += (country_pred == target).sum().item()
            correct += country_preds.eq(targets.view_as(country_preds)).sum().item()
        accuracy = correct / total_samples
        print('Accuracy on name-country test set is %.3f %%\n' % (100 * accuracy))  # 化为百分数
    return accuracy


## 计算经过的时间
def timePassed(start_time):  # 参数:开始时间
    time_passed = time.time() - start_time  # 经过的时间
    # 换算为分和秒
    minute = math.floor(time_passed / 60)  # 取下整
    second = time_passed - minute * 60
    return [minute, second]  # 返回值:几分几秒


'''4. Main cycle'''
if __name__ == '__main__':
    # 数据准备
    training_set = NameDataset(is_training_set=True)
    train_loader = DataLoader(dataset=training_set, batch_size=BATCH_SIZE, shuffle=True)
    test_set = NameDataset(is_training_set=False)
    test_loader = DataLoader(dataset=test_set, batch_size=BATCH_SIZE, shuffle=False)

    NUM_COUNTRIES = training_set.getCountriesNum()  # 给NUM_COUNTRIES赋值

    # 定义模型对象
    classifier_model = RNNClassifier(NUM_CHARS, HIDDEN_SIZE, NUM_COUNTRIES,
                                     NUM_LAYERS)  # input_size, hidden_size, output_size, num_layers
    if USE_GPU:  # 是否用GPU训练模型
        device = torch.device("cuda:0")  # 申请GPU cuda:0
        classifier_model.to(device)  # 将模型迁移到GPU上

    # 构建loss function和optimizer
    criterion = torch.nn.CrossEntropyLoss()
    optimizer = torch.optim.Adam(classifier_model.parameters(), lr=0.001)

    # training and test
    start_time = time.time()  # 开始时间
    print("The num of total training epochs is %d. " % NUM_EPOCHS)
    accuracy_list = []
    for epoch in range(NUM_EPOCHS):
        train()
        accuracy = test()
        accuracy_list.append(accuracy)

    # 作图 epoch-accuracy
    epoch_list = np.arange(1, NUM_EPOCHS + 1, 1)  # epoch从1到NUM_EPOCHS
    accuracy_list = np.array(accuracy_list)
    plt.plot(epoch_list, accuracy_list)
    plt.xlabel("epoch")
    plt.ylabel("accuracy")
    plt.grid()
    plt.show()

  • 0
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个,百个,甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。 Quartz的优势: 1、Quartz是一个任务调度框架(库),它几乎可以集成到任何应用系统中。 2、Quartz是非常灵活的,它让您能够以最“自然”的方式来编写您的项目的代码,实现您所期望的行为 3、Quartz是非常轻量级的,只需要非常少的配置 —— 它实际上可以被跳出框架来使用,如果你的需求是一些相对基本的简单的需求的话。 4、Quartz具有容错机制,并且可以在重启服务的时候持久化(”记忆”)你的定时任务,你的任务也不会丢失。 5、可以通过Quartz,封装成自己的分布式任务调度,实现强大的功能,成为自己的产品。6、有很多的互联网公司也都在使用Quartz。比如美团 Spring是一个很优秀的框架,它无缝的集成了Quartz,简单方便的让企业级应用更好的使用Quartz进行任务的调度。   课程说明:在我们的日常开发中,各种大型系统的开发少不了任务调度,简单的单机任务调度已经满足不了我们的系统需求,复杂的任务会让程序猿头疼, 所以急需一套专门的框架帮助我们去管理定时任务,并且可以在多台机器去执行我们的任务,还要可以管理我们的分布式定时任务。本课程从Quartz框架起,由浅到深,从使用到结构分析,再到源码分析,深入解析Quartz、Spring+Quartz,并且会解相关原理, 让大家充分的理解这个框架和框架的设计思想。由于互联网的复杂性,为了满足我们特定的需求,需要对Spring+Quartz进行二次开发,整个二次开发过程都会进行解。Spring被用在了越来越多的项目中, Quartz也被公认为是比较好用的定时器设置工具,学完这个课程后,不仅仅可以熟练掌握分布式定时任务,还可以深入理解大型框架的设计思想。
[入门数据分析的第一堂课]这是一门为数据分析小白量身打造的课程,你从网络或者公众号收集到很多关于数据分析的知识,但是它们零散不成体系,所以第一堂课首要目标是为你介绍:Ø  什么是数据分析-知其然才知其所以然Ø  为什么要学数据分析-有目标才有动力Ø  数据分析的学习路线-有方向走得更快Ø  数据分析的模型-分析之道,快速形成分析思路Ø  应用案例及场景-分析之术,掌握分析方法[哪些同学适合学习这门课程]想要转行做数据分析师的,零基础亦可工作中需要数据分析技能的,例如运营、产品等对数据分析感兴趣,想要更多了解的[你的收获]n  会为你介绍数据分析的基本情况,为你展现数据分析的全貌。让你清楚知道自己该如何在数据分析地图上行走n  会为你介绍数据分析的分析方法和模型。这部分是数据分析的道,只有学会底层逻辑,能够在面对问题时有自己的想法,才能够下一步采取行动n  会为你介绍数据分析的数据处理和常用分析方法。这篇是数据分析的术,先有道,后而用术来实现你的想法,得出最终的结论。n  会为你介绍数据分析的应用。学到这里,你对数据分析已经有了初步的认识,并通过一些案例为你展现真实的应用。[专享增值服务]1:一对一答疑         关于课程问题可以通过微信直接询问老师,获得老师的一对一答疑2:转行问题解答         在转行的过程中的相关问题都可以询问老师,可获得一对一咨询机会3:打包资料分享         15本数据分析相关的电子书,一次获得终身学习
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值