阁下和不同风起

NLP学习笔记-循环神经网络RNN、情感分类、LSTM（二）

循环神经网络和自然语言处理介绍

1. 文本的`tokenization`

1.1 概念和工具的介绍

tokenization就是通常所说的分词，分出的每一个词语我们把它称为token。

常见的分词工具很多，比如：

jieba分词：https://github.com/fxsjy/jieba
清华大学的分词工具THULAC：https://github.com/thunlp/THULAC-Python

1.2 中英文分词的方法

把句子转化为词语
- 比如：我爱深度学习 可以分为[我，爱，深度学习]
把句子转化为单个字
- 比如：我爱深度学习的token是[我，爱，深，度，学，习]

2. `N-gram`表示方法

前面我们说，句子可以用但个字，词来表示，但是有的时候，我们可以用2个、3个或者多个词来表示。

N-gram一组一组的词语，其中的N表示能够被一起使用的词的数量

例如：

In [59]: text = "深度学习（英语：deep learning）是机器学习的分支，是一种以人工神经网络为架构，对数据进行表征学习的算法。"

# jieba.cut() 返回一个生成器
# jieba.lcut() 返回一个列表
In [60]: cuted = jieba.lcut(text)

In [61]: [cuted[i:i+2] for i in range(len(cuted)-1)] #N-gram 中n=2时
Out[61]:[['深度', '学习'],
 ['学习', '（'],
 ['（', '英语'],
 ['英语', '：'],
 ['：', 'deep'],
 ['deep', ' '],
 [' ', 'learning'],
 ['learning', '）'],
 ['）', '是'],
 ['是', '机器'],
 ['机器', '学习'],
 ['学习', '的'],
 ['的', '分支'],
 ['分支', '，'],
 ['，', '是'],
 ['是', '一种'],
 ['一种', '以'],
 ['以', '人工神经网络'],
 ['人工神经网络', '为'],
 ['为', '架构'],
 ['架构', '，'],
 ['，', '对'],
 ['对', '数据'],
 ['数据', '进行'],
 ['进行', '表征'],
 ['表征', '学习'],
 ['学习', '的'],
 ['的', '算法'],
 ['算法', '。']]

在传统的机器学习中，使用N-gram方法往往能够取得非常好的效果，但是在深度学习比如RNN中会自带N-gram的效果。

3. 向量化

因为文本不能够直接被模型计算，所以需要将其转化为向量

把文本转化为向量有两种方法：

转化为one-hot编码
转化为word embedding

3.1 one-hot 编码

在one-hot编码（使用稀疏向量表示文本，但占用空间较大，一般不常使用）中，每一个token使用一个长度为N的向量表示，N表示词典的数量（即待训练样本中不重复的词语的个数）

即：把待处理的文档进行分词或者是N-gram处理，然后进行去重得到词典，假设我们有一个文档：深度学习，那么进行one-hot处理后的结果如下：

token	one-hot encoding
深	1000
度	0100
学	0010
习	0001

3.2 word embedding

word embedding是深度学习中表示文本常用的一种方法。和one-hot编码不同，word embedding使用了浮点型的稠密矩阵来表示token（分出的每一个词语我们把它称为token）。根据词典的大小，我们的向量通常使用不同的维度，例如100,256,300等。其中向量中的每一个值是一个参数，其初始值是随机生成的，之后会在训练的过程中进行学习而获得。

如果我们文本中有20000个词语，如果使用one-hot编码，那么我们会有20000*20000的矩阵，其中大多数的位置都为0，但是如果我们使用word embedding来表示的话，只需要20000* 维度，比如20000*300

形象的表示就是：

token	num	vector
词1	0	`[w11,w12,w13...w1N]` ,其中N表示维度（dimension）
词2	1	`[w21,w22,w23...w2N]`
词3	2	`[w31,w23,w33...w3N]`
…	….	…
词m	m	`[wm1,wm2,wm3...wmN]`,其中m表示词典的大小

我们会把所有的文本转化为向量，把句子用向量来表示

但是在这中间，我们会先把token使用数字来表示，再把数字使用向量来表示。

即：token---> num ---->vector

3.3 word embedding API

torch.nn.Embedding(num_embeddings,embedding_dim)

参数介绍：

num_embeddings：词典的大小，即不重复词语个数即行数
embedding_dim：embedding的维度，表示采用多长的向量表示一个词语

使用方法：

embedding = nn.Embedding(vocab_size,300) #实例化
input_embeded = embedding(input)         #进行embedding的操作

3.4 数据的形状变化

思考：每个batch中的每个句子有10个词语，经过形状为[20，4]的Word emebedding之后，原来的句子会变成什么形状？

每个词语用长度为4的向量表示，所以，最终句子会变为[batch_size,10,4]的形状。

增加了一个维度，这个维度是embedding的dim
[batch_size, seq_len] -----> [batch_size, seq_len, embedding_dim]

文本情感分类

1. 案例介绍

为了对前面的word embedding这种常用的文本向量化的方法进行巩固，这里我们会完成一个文本情感分类的案例

现在我们有一个经典的数据集IMDB数据集，地址：http://ai.stanford.edu/~amaas/data/sentiment/，这是一份包含了5万条流行电影的评论数据，其中训练集25000条，测试集25000条。数据格式如下：

下图左边为名称，其中名称包含两部分，分别是序号和情感评分，（1-4为neg，5-10为pos），右边为评论内容

根据上述的样本，需要使用pytorch完成模型，实现对评论情感进行预测

2. 思路分析

首先可以把上述问题定义为分类问题，情感评分分为1-10，10个类别（也可以理解为回归问题，这里当做分类问题考虑）。那么根据之前的经验，我们的大致流程如下：

准备数据集
构建模型
模型训练
模型评估

知道思路之后，那么我们一步步来完成上述步骤

3. 准备数据集

准备数据集和之前的方法一样，实例化dataset，准备dataloader，最终我们的数据可以处理成如下格式：

图中 table 即为label

其中有几点需要注意：

如何完成基础打Dataset的构建和Dataloader的准备
每个batch中文本的长度不一致的问题如何解决
每个batch中的文本如何转化为数字序列

3.1 基础Dataset的准备

import torch
from torch.utils.data import DataLoader,Dataset
import os
import re

data_base_path = r"data\aclImdb"

#1. 定义tokenize的方法
def tokenize(text):
    # fileters = '!"#$%&()*+,-./:;<=>?@[\\]^_`{|}~\t\n'
    fileters = ['!','"','#','$','%','&','\(','\)','\*','\+',',','-','\.','/',':',';','<','=','>','\?','@'
        ,'\[','\\','\]','^','_','`','\{','\|','\}','~','\t','\n','\x97','\x96','”','“',]
    text = re.sub("<.*?>"," ",text,flags=re.S)
    text = re.sub("|".join(fileters)," ",text,flags=re.S)
    return [i.strip() for i in text.split()]

#2. 准备dataset
class ImdbDataset(Dataset):
    def __init__(self,mode):
        if mode=="train":
            text_path = [os.path.join(data_base_path,i)  for i in ["train/neg","train/pos"]]
        else:
            text_path =  [os.path.join(data_base_path,i)  for i in ["test/neg","test/pos"]]

        self.total_file_path_list = []
        for i in text_path:
            self.total_file_path_list.extend([os.path.join(i,j) for j in os.listdir(i)])


    def __getitem__(self, idx):
        cur_path = self.total_file_path_list[idx]

        cur_filename = os.path.basename(cur_path)
        label = int(cur_filename.split("_")[-1].split(".")[0]) -1 #处理标题，获取label，转化为从[0-9]
        text = tokenize(open(cur_path).read().strip()) #直接按照空格进行分词
        return label,text

    def __len__(self):
        return len(self.total_file_path_list)
    
 # 2. 实例化，准备dataloader
dataset = ImdbDataset(mode="train")
dataloader = DataLoader(dataset=dataset,batch_size=2,shuffle=True)

#3. 观察数据输出结果
for idx,(label,text) in enumerate(dataloader):
    print("idx：",idx)
    print("label:",label)
    print("text:",text)
    break

输出如下：

idx： 0
label: tensor([3, 1])
text: [('I', 'Want'), ('thought', 'a'), ('this', 'great'), ('was', 'recipe'), ('a', 'for'), ('great', 'failure'), ('idea', 'Take'), ('but', 'a'), ('boy', 's'), ('was', 'y'), ('it', 'plot'), ('poorly', 'add'), ('executed', 'in'), ('We', 'some'), ('do', 'weak'), ('get', 'completely'), ('a', 'undeveloped'), ('broad', 'characters'), ('sense', 'and'), ('of', 'than'), ('how', 'throw'), ('complex', 'in'), ('and', 'the'), ('challenging', 'worst'), ('the', 'special'), ('backstage', 'effects'), ('operations', 'a'), ('of', 'horror'), ('a', 'movie'), ('show', 'has'), ('are', 'known'), ('but', 'Let'), ('virtually', 'stew'), ('no', 'for'), ...('show', 'somehow'), ('rather', 'destroy'), ('than', 'every'), ('anything', 'copy'), ('worth', 'of'), ('watching', 'this'), ('for', 'film'), ('its', 'so'), ('own', 'it'), ('merit', 'will')]

明显，其中的text内容出现对应，和想象的不太相似，出现问题的原因在于Dataloader中的参数collate_fn

collate_fn的默认值为torch自定义的default_collate,collate_fn的作用就是对每个batch进行处理，而默认的default_collate处理出错。

解决问题的思路：

手段1：考虑先把数据转化为数字序列，观察其结果是否符合要求，之前使用DataLoader并未出现类似错误

手段2：考虑自定义一个collate_fn，观察结果

这里使用方式2，自定义一个collate_fn,然后观察结果：

def collate_fn(batch):
	#batch是list，其中是一个一个元组，每个元组是dataset中__getitem__的结果
    batch = list(zip(*batch))
    labes = torch.tensor(batch[0],dtype=torch.int32)
    texts = batch[1]
    del batch
    return labes,texts
dataloader = DataLoader(collate_fn=collate_fn，dataset=dataset,batch_size=2,shuffle=True)

#此时输出正常
for idx,(label,text) in enumerate(dataloader):
    print("idx：",idx)
    print("label:",label)
    print("text:",text)
    break

import torch
from torch.utils.data import Dataset, DataLoader
import os
import re

"""
完成数据集准备
"""
TRAIN_PATH = r"E:\data\aclImdb\train"
TEST_PATH = r"E:\data\aclImdb\test"


# 分词
def tokenlize(content):
    content = re.sub(r"<.*?>", " ", content)
    filters = ['!','"','#','$','%','&','\(','\)','\*','\+',',','-','\.','/',':',';','<','=','>','\?','@'
        ,'\[','\\','\]','^','_','`','\{','\|','\}','~','\t','\n','\x97','\x96','”','“',]
    content = re.sub("|".join(filters), " ", content)
    tokens = [i.strip().lower() for i in content.split()]
    return tokens


class ImbdDateset(Dataset):
    def __init__(self, train = True):
        self.train_data_path = TRAIN_PATH
        self.test_data_path = TEST_PATH
        # 通过train和data_path控制读取train或者test数据集
        data_path = self.train_data_path if train else self.test_data_path
        # 把所有文件名放入列表
        # temp_data_path = [data_path + '/pos', data_path + '/neg']
        temp_data_path = [os.path.join(data_path , 'pos'), os.path.join(data_path , 'neg')]
        self.total_file_path = []  # 所有pos,neg评论文件的path
        # 获取每个文件名字，并拼接路径
        for path in temp_data_path:
            file_name_list = os.listdir(path)
            file_path_list = [os.path.join(path, i) for i in file_name_list if i.endswith('.txt')]
            self.total_file_path.extend(file_path_list)


    def __getitem__(self, index):
        # 获取index的path
        file_path = self.total_file_path[index]
        # 获取label
        label_str = file_path.split('\\')[-2]
        label = 0 if label_str =='neg' else 1
        # 获取content
        tokens = tokenlize(open(file_path).read())
        return tokens, label


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

def get_dataloader(train = True):
    imdb_dataset = ImbdDateset(train)
    data_loader = DataLoader(imdb_dataset, shuffle = True, batch_size = 2, collate_fn = collate_fn)
    return data_loader


# 重新定义collate_fn
def collate_fn(batch):
    """
    :param batch: (一个__getitem__[tokens, label], 一个__getitem__[tokens, label],..., batch_size个)
    :return:
    """
    content, label = list(zip(*batch))
    return content, label


if __name__ == '__main__':
    for idx, (input, target) in enumerate(get_dataloader()):
        print(idx)
        print(input)
        print(target)
        break

0
(['new', 'york', 'city', 'houses', 'one', 'man', 'above', 'all', 'others', 'the', 'possibly', 'immortal', 'dr', 'anton', 'mordrid', 'mordrid', 'is', 'the', 'sworn', 'protector', 'of', 'humanity', 'using', 'his', 'magical', 'powers', 'to', 'keep', 'his', 'brother', 'and', 'rival', 'kabal', 'chained', 'up', 'so', 'that', 'he', 'may', 'not', 'enslave', 'the', 'human', 'race', 'well', "wouldn't", 'you', 'know', 'it', 'a', 'prophesy', 'comes', 'true', 'and', 'kabal', 'breaks', 'free', 'and', 'begins', 'collecting', 'elements', 'including', 'platinum', 'and', 'uranium', 'for', 'his', 'alchemy', 'experiments', 'with', 'the', 'help', 'of', 'a', 'police', 'woman', 'named', 'sam', 'can', 'mordrid', 'defeat', 'his', 'evil', 'brother', 'dr', 'mordrid', 'comes', 'to', 'me', 'courtesy', 'of', 'charles', 'band', 'in', 'the', 'full', 'moon', 'archive', 'collection', 'i', 'had', 'not', 'heard', 'of', 'it', 'which', 'is', 'a', 'bit', 'odd', 'given', 'that', "i'm", 'a', 'big', 'fan', 'of', 'jeffrey', 'combs', 'mordrid', 'and', 'the', 'film', "isn't", 'that', 'old', 'but', 'now', "it's", 'mine', 'and', 'i', 'can', 'enjoy', 'it', 'again', 'and', 'again', 'the', 'film', 'certainly', 'is', 'fun', 'in', 'the', 'classic', 'full', 'moon', 'style', 'richard', 'band', 'provides', 'the', 'music', 'which', "doesn't", 'differ', 'much', 'from', 'all', 'his', 'other', 'scores', 'and', 'brian', 'thompson', 'plays', 'the', 'evil', 'kabal', 'we', 'even', 'have', 'animated', 'dinosaur', 'bones', 'what', 'more', 'do', 'you', 'want', 'of', 'course', 'the', 'cheese', 'factor', 'is', 'high', 'i', 'felt', 'much', 'of', 'the', 'film', 'was', 'a', 'rip', 'off', 'of', 'the', 'dr', 'strange', 'comics', 'and', 'the', 'blue', 'pantsuit', 'was', 'silly', 'and', 'plot', 'holes', 'are', 'everywhere', 'i', 'could', 'list', 'at', 'least', 'five', 'but', 'why', 'bother', 'and', 'why', 'does', 'the', 'ancient', 'symbol', 'of', 'mordrid', 'and', 'kabal', 'look', 'suspiciously', 'like', 'a', 'hammer', 'and', 'sickle', 'combs', 'has', 'never', 'been', 'a', 'strong', 'actor', 'so', 'he', 'fits', 'right', 'in', 'with', 'the', 'cheese', 'these', "aren't", 'complaints', 'full', 'moon', 'fans', 'have', 'come', 'to', 'expect', 'these', 'things', 'and', 'devour', 'them', 'like', 'crack', 'laced', 'grape', 'nuts', "i'm", 'guilty', 'i', 'loved', 'this', 'film', 'if', "you're", 'not', 'a', 'full', 'moon', 'fan', 'or', 'a', 'jeffrey', 'combs', 'fan', 'you', 'may', 'want', 'to', 'look', 'elsewhere', 'but', 'if', 'you', 'like', 'the', 'early', '1990s', 'style', 'of', 'movie', 'making', 'and', 'haircuts', "you'll", 'eat', 'this', 'up', 'stallone', 'and', 'schwarzenegger', 'fans', 'might', 'like', 'seeing', 'brian', 'thompson', 'as', 'a', 'villain', 'looking', 'as', 'goony', 'as', 'ever', 'and', 'not', 'being', 'able', 'to', 'enunciate', 'english', 'beyond', 'a', 'third', 'grade', 'level', 'i', 'did', 'i', 'wish', 'there', 'was', 'a', 'mordrid', 'ii', 'but', 'the', 'company', 'that', 'makes', 'a', 'sequel', 'to', 'practically', 'everything', 'is', 'gingerdead', 'man', '3', 'really', 'necessary', 'passed', 'on', 'this', 'one'], ['we', 'went', 'to', 'the', 'movie', 'with', 'a', 'group', 'because', 'the', 'play', 'we', 'were', 'going', 'to', 'was', 'cancelled', 'it', 'is', 'without', 'doubt', 'one', 'of', 'the', 'worst', 'movies', 'ever', 'it', 'is', 'not', 'that', 'i', "don't", 'like', 'cult', 'movies', 'i', 'do', 'but', 'nothing', 'happens', 'in', 'the', 'film', 'one', 'does', 'not', 'feel', 'any', 'connection', 'with', 'the', 'characters', 'whatsoever', 'endless', 'times', 'without', 'dialog', 'and', 'the', 'car', 'how', 'do', 'thay', 'carry', 'a', 'huge', 'tent', 'and', 'beds', 'chairs', 'and', 'clothing', 'for', 'every', 'day', 'in', 'that', 'car', 'it', 'is', 'a', 'two', 'seater', 'i', 'have', 'to', 'say', 'however', 'the', 'scenery', 'is', 'beautiful', 'but', 'not', 'in', 'a', 'movie', 'the', 'director', 'should', 'have', 'made', 'a', 'photoshoot', 'of', 'the', 'movie', 'so', 'that', 'we', 'could', 'skip', 'about', '80', 'minutes', 'of', 'useless', 'time', 'in', 'with', 'nothing', 'happens', 'anyway', 'i', 'would', 'not', 'recommend', 'it', 'as', 'it', 'is', 'a', 'waste', 'of', 'your', 'time'])
(1, 0)

Process finished with exit code 0

3.2 文本序列化

再介绍word embedding的时候，我们说过，不会直接把文本转化为向量，而是先转化为数字，再把数字转化为向量，那么这个过程该如何实现呢？

这里我们可以考虑把文本中的每个词语和其对应的数字，使用字典保存，同时实现方法把句子通过字典映射为包含数字的列表。

实现文本序列化之前，考虑以下几点:

如何使用字典把词语和数字进行对应
不同的词语出现的次数不尽相同，是否需要对高频或者低频词语进行过滤，以及总的词语数量是否需要进行限制
得到词典之后，如何把句子转化为数字序列，如何把数字序列转化为句子
不同句子长度不相同，每个batch的句子如何构造成相同的长度（可以对短句子进行填充，填充特殊字符）
对于新出现的词语在词典中没有出现怎么办（可以使用特殊字符代理）

思路分析：

对所有句子进行分词
词语存入字典，根据次数对词语进行过滤，并统计次数
实现文本转数字序列的方法
实现数字序列转文本方法

import numpy as np

class Word2Sequence():
    UNK_TAG = "UNK"  # 出现的特殊字符
    PAD_TAG = "PAD"  # 填充短句标记

    UNK = 0
    PAD = 1

    def __init__(self):
        self.dict = {
     
            self.UNK_TAG :self.UNK,
            self.PAD_TAG :self.PAD
        }
        self.fited = False

    def to_index(self,word):
        """word -> index"""
        assert self.fited == True,"必须先进行fit操作"
        return self.dict.get(word,self.UNK)

    def to_word(self,index):
        """index -> word"""
        assert self.fited , "必须先进行fit操作"
        if index in self.inversed_dict:
            return self.inversed_dict[index]
        return self.UNK_TAG

    def __len__(self):
        return self(self.dict)

    def fit(self, sentences, min_count=1, max_count=None, max_feature=None):
        """
        :param sentences:[[word1,word2,word3],[word1,word3,wordn..],...]
        :param min_count: 最小出现的次数
        :param max_count: 最大出现的次数
        :param max_feature: 总词语的最大数量
        :return:
        """
        count = {
     }
        for sentence in sentences:
            for a in sentence:
                if a not in count:
                    count[a] = 0
                count[a] += 1

        # 比最小的数量大和比最大的数量小的需要
        if min_count is not None:
            count = {
     k: v for k, v in count.items() if v >= min_count}
        if max_count is not None:
            count = {
     k: v for k, v in count.items() if v <= max_count}

        # 限制最大的数量
        if isinstance(max_feature, int):
            count = sorted(list(count.items()), key=lambda x: x[1])
            if max_feature is not None and len(count) > max_feature:
                count = count[-int(max_feature):]
            for w, _ in count:
                self.dict[w] = len(self.dict)
        else:
            for w in sorted(count.keys()):
                self.dict[w] = len(self.dict)

        self.fited = True
        # 准备一个index->word的字典
        self.inversed_dict = dict(zip(self.dict.values(), self.dict.keys()))

    def transform(self, sentence,max_len=None):
        """
        实现吧句子转化为数组（向量）
        :param sentence:
        :param max_len:
        :return:
        """
        assert self.fited, "必须先进行fit操作"
        if max_len is not None:
            r = [self.PAD]*max_len
        else:
            r = [self.PAD]*len(sentence)
        if max_len is not None and len(sentence)>max_len:
            sentence=sentence[:max_len]
        for index,word in enumerate(sentence):
            r[index] = self.to_index(word)
        return np.array(r,dtype=np.int64)

    def inverse_transform(self,indices):
        """
        实现从数组 转化为文字
        :param indices: [1,2,3....]
        :return:[word1,word2.....]
        """
        sentence = []
        for i in indices:
            word = self.to_word(i)
            sentence.append(word)
        return sentence

if __name__ == '__main__':
    w2s = Word2Sequence()
    w2s.fit([
        ["你", "好", "么"],
        ["你", "好", "哦"]])

    print(w2s.dict)
    print(w2s.fited)
    print(w2s.transform(["你","好","嘛"]))
    print(w2s.transform(["你好嘛"],max_len=10))

完成了wordsequence之后，接下来就是保存现有样本中的数据字典，方便后续的使用。

import numpy as np
"""
构建词典,实现方法把句子转换为序列,和其翻转
"""

class Word2Sequence(object):
    # 2个特殊类属性，标记特殊字符和填充标记
    UNK_TAG = 'UNK'
    PAD_TAG = 'PAD'

    UNK = 0
    PAD = 1


    def __init__(self):
        self.dict = {
     
            # 保存词语和对应的数字
            self.UNK_TAG : self.UNK,
            self.PAD_TAG : self.PAD
        }
        self.count = {
     }  # 统计词频


    def fit(self, sentence):
        """
        把单个句子保存到dict中
        :param sentence: [word1, word2 , ... , ]
        :return:
        """
        for word in sentence:
            # 对word出现的频率进行统计，当word不在sentence时，返回值是0，当word在sentence中时，返回+1，以此进行累计计数
            self.count[word] = self.count.get(word, 0) + 1



    def build_vocab(self, min = 5, max = None, max_features = None):
        """
        生成词典
        :param min:最小词频数
        :param max:最大词频数
        :param max_feature:一共保留多少词语
        :return:
        """
        # 删除count < min 的词语,即保留count > min 的词语
        if min is not None:
            self.count = {
     word : value for word, value in self.count.items() if value > min}
        # 删除count > min 的词语,即保留count < max 的词语
        if max is not None:
            self.count = {
     word : value for word, value in self.count.items() if value < max}
        # 限制保留的词语数
        if max_features is not None:
            # sorted 返回一个列表[(key1, value1), (key2, value2),...]，True为升序
            temp = sorted(self.count.items(), key = lambda x : x[-1], reverse = True)[:max_features]
            self.count = dict(temp)
            for word in self.count:
                self.dict[word] = len(self.dict)


        # 得到一个翻转的dict字典
        # zip方法要比{value: word for word, value in self.dict.items()}快
        self.inverse_dict = dict(zip(self.dict.values(), self.dict.keys()))


    def transform(self, sentence, max_len = None):
        """
        把句子转换为序列
        :param sentence: [word1, word2...]
        :param max_len: 对句子进行填充或者裁剪
        :return:
        """
        if max_len is not None:
            # 句子长度小于最大长度，进行填充
            if max_len > len(sentence):
                sentence = sentence + [self.PAD_TAG] * (max_len - len(sentence))
            # 句子长度大于最大长度，进行裁剪
            if max_len < len(sentence):
                sentence = sentence[:max_len]
        # for word in sentence:
        #     self.dict.get(word, self.UNK)
        # 字典的get(key, default=None) 如果指定键不存在，则返回默认值None。
        return [self.dict.get(word, self.UNK) for word in sentence]


    def inverse_transform(self, indices):
        """
        把序列转换为句子
        :param indices: [1, 2, 3, ...]
        :return:
        """
        return [self.inverse_dict.get(idx) for idx in indices]


if __name__ == '__main__':
    ws = Word2Sequence()
    ws.fit(["我", "是", "我"])
    ws.fit(["我", "是", "谁"])
    ws.build_vocab(min = 1, max_features=5)
    print(ws.dict)
    ret = ws.transform(['我', '爱', '北京'], max_len=10)
    print(ret)
    print(ws.inverse_transform(ret))

{'UNK': 0, 'PAD': 1, '我': 2, '是': 3}
[2, 0, 0, 1, 1, 1, 1, 1, 1, 1]
['我', 'UNK', 'UNK', 'PAD', 'PAD', 'PAD', 'PAD', 'PAD', 'PAD', 'PAD']

实现对IMDB数据的处理和保存
pickle 模块
tqdm 模块

#1. 对IMDB的数据记性fit操作
def fit_save_word_sequence():
    from wordSequence import Word2Sequence

    ws = Word2Sequence()
    train_path = [os.path.join(data_base_path,i)  for i in ["train/neg","train/pos"]]
    total_file_path_list = []
    for i in train_path:
        total_file_path_list.extend([os.path.join(i, j) for j in os.listdir(i)])
    for cur_path in tqdm(total_file_path_list,ascii=True,desc="fitting"):
        ws.fit(tokenize(open(cur_path).read().strip()))
    ws.build_vocab()
    # 对wordSequesnce进行保存
    pickle.dump(ws,open("./model/ws.pkl","wb"))

#2. 在dataset中使用wordsequence
ws = pickle.load(open("./model/ws.pkl","rb"))

def collate_fn(batch):
    MAX_LEN = 500 
    #MAX_LEN = max([len(i) for i in texts]) #取当前batch的最大值作为batch的最大长度

    batch = list(zip(*batch))
    labes = torch.tensor(batch[0],dtype=torch.int)

    texts = batch[1]
    #获取每个文本的长度
    lengths = [len(i) if len(i)<MAX_LEN else MAX_LEN for i in texts]
    texts = torch.tensor([ws.transform(i, MAX_LEN) for i in texts])
    del batch
    return labes,texts,lengths

#3. 获取输出
dataset = ImdbDataset(ws,mode="train")
    dataloader = DataLoader(dataset=dataset,batch_size=20,shuffle=True,collate_fn=collate_fn)
    for idx,(label,text,length) in enumerate(dataloader):
        print("idx：",idx)
        print("label:",label)
        print("text:",text)
        print("length:",length)
        break

# 由于pickle特殊性，需要在此导入Word2Sequence
from demo3_Word2Sequence import Word2Sequence
import pickle
import os
from demo2_word_embedding import tokenlize
from tqdm import tqdm  # 显示当前迭代进度

TRAIN_PATH = r"E:\data\aclImdb\train"


if __name__ == '__main__':
    ws = Word2Sequence()
    temp_data_path = [os.path.join(TRAIN_PATH, 'pos'), os.path.join(TRAIN_PATH, 'neg')]
    for data_path in temp_data_path:
        # 获取每一个文件的路径
        file_paths = [os.path.join(data_path, file_name) for file_name in os.listdir(data_path)]
        for file_path in tqdm(file_paths):
            sentence = tokenlize(open(file_path, errors = 'ignore').read())
            ws.fit(sentence)
    ws.build_vocab(max = 10, max_features = 10000)
    pickle.dump(ws, open('./model/ws.pkl', 'wb'))
    print(len(ws.dict))

输出如下

idx： 0
label: tensor([ 7,  4,  3,  8,  1, 10,  7, 10,  7,  2,  1,  8,  1,  2,  2,  4,  7, 10,
         1,  4], dtype=torch.int32)
text: tensor([[ 50983,  77480,  82366,  ...,      1,      1,      1],
        [ 54702,  57262, 102035,  ...,  80474,  56457,  63180],
        [ 26991,  57693,  88450,  ...,      1,      1,      1],
        ...,
        [ 51138,  73263,  80428,  ...,      1,      1,      1],
        [  7022,  78114,  83498,  ...,      1,      1,      1],
        [  5353, 101803,  99148,  ...,      1,      1,      1]])
length: [296, 500, 221, 132, 74, 407, 500, 130, 54, 217, 80, 322, 72, 156, 94, 270, 317, 117, 200, 379]

思考：前面我们自定义了MAX_LEN作为句子的最大长度，如果我们需要把每个batch中的最长的句子长度作为当前batch的最大长度，该如何实现？

4. 构建模型

这里我们只练习使用word embedding，所以模型只有一层，即：

数据经过word embedding
nn.Embedding(num_embeddings - 词嵌入字典大小即一个字典里要有多少个词，embedding_dim - 每个词嵌入向量的大小。)
数据通过全连接层返回结果，计算log_softmax

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch import optim
from build_dataset import get_dataloader,ws,MAX_LEN

class IMDBModel(nn.Module):
    def __init__(self,max_len):
        super(IMDBModel,self).__init__()
        self.embedding = nn.Embedding(len(ws),300,padding_idx=ws.PAD) #[N,300]
        self.fc = nn.Linear(max_len*300,10)  #[max_len*300,10]

    def forward(self, x):
        embed = self.embedding(x) #[batch_size,max_len,300]
        embed = embed.view(x.size(0),-1)
        out = self.fc(embed)
        return F.log_softmax(out,dim=-1)

5. 模型的训练和评估

训练流程和之前相同

实例化模型，损失函数，优化器
遍历dataset_loader，梯度置为0，进行向前计算
计算损失，反向传播优化损失，更新参数

train_batch_size = 128
test_batch_size = 1000
imdb_model = IMDBModel(MAX_LEN)
optimizer = optim.Adam(imdb_model.parameters())
criterion = nn.CrossEntropyLoss()

def train(epoch):
    mode = True
    imdb_model.train(mode)
    train_dataloader =get_dataloader(mode,train_batch_size)
    for idx,(target,input,input_lenght) in enumerate(train_dataloader):
        optimizer.zero_grad()
        output = imdb_model(input)
        loss = F.nll_loss(output,target) #traget需要是[0,9]，不能是[1-10]
        loss.backward()
        optimizer.step()
        if idx %10 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, idx * len(input), len(train_dataloader.dataset),
                       100. * idx / len(train_dataloader), loss.item()))

            torch.save(imdb_model.state_dict(), "model/mnist_net.pkl")
            torch.save(optimizer.state_dict(), 'model/mnist_optimizer.pkl')
            
 def test():
    test_loss = 0
    correct = 0
    mode = False
    imdb_model.eval()
    test_dataloader = get_dataloader(mode, test_batch_size)
    with torch.no_grad():
        for target, input, input_lenght in test_dataloader:
            output = imdb_model(input)
            test_loss  += F.nll_loss(output, target,reduction="sum")
            pred = torch.max(output,dim=-1,keepdim=False)[-1]
            correct = pred.eq(target.data).sum()
        test_loss = test_loss/len(test_dataloader.dataset)
        print('\nTest set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\n'.format(
            test_loss, correct, len(test_dataloader.dataset),
            100. * correct / len(test_dataloader.dataset)))

if __name__ == '__main__':
    test()
    for i in range(3):
        train(i)
        test()

"""
定义模型
"""
import  torch.nn as nn
from demo5_lib import ws, max_len
import torch.nn.functional as F
from torch.optim import Adam
from demo2_word_embedding import get_dataloader
from tqdm import tqdm
import torch
import numpy as np

class Mymodel(nn.Module):
    def __init__(self):
        super(Mymodel, self).__init__()
        # nn.Embedding(num_embeddings - 词嵌入字典大小即一个字典里要有多少个词，embedding_dim - 每个词嵌入向量的大小。)
        self.embedding = nn.Embedding(len(ws), 100)
        self.fc = nn.Linear(max_len * 100, 2)


    def forward(self, input):
        """
        :param input: 形状[batch_size, max_len]
        :return:
        """
        x = self.embedding(input)  # 进行embedding，形状[batch_size, max_len, 100]
        x = x.view([-1,max_len * 100])
        output = self.fc(x)
        return F.log_softmax(output, dim=-1)


model = Mymodel()
optimizer = Adam(model.parameters(), lr = 0.01)
# 训练
def train(epoch):
    for idx, (input, targer) in enumerate(get_dataloader(train = True)):
        output = model(input)
        optimizer.zero_grad()
        loss = F.nll_loss(output, targer)
        loss.backward()
        optimizer.step()
        print(loss.item())
# 评估
def test():
    acc_list = []
    loss_list = []
    # 开启模型评估模式
    model.eval()
    # 获取测试集数据
    test_dataloader = get_dataloader(train = False)
    for idx,(input, target) in tqdm(enumerate(test_dataloader)):
        with torch.no_grad():
            output = model(input)
            # 计算当前损失
            cur_loss = F.nll_loss(output, target)
            loss_list.append(cur_loss)
            pred = output.max(dim = -1)[-1]
            # 计算当前准确率
            cur_acc = pred.eq(target).float().mean()
            acc_list.append(cur_acc)
    print('准确率为:%lf, 损失为:%lf' % (np.mean(acc_list), np.mean(loss_list)))

if __name__ == '__main__':
    for i in tqdm(range(1)):
        train(i)
    test()

这里仅仅使用了一层全连接层，其分类效果不会很好，这里重点是理解常见的模型流程和word embedding的使用方法

循环神经网络

1. 循环神经网络的介绍

在普通的神经网络中，信息的传递是单向的，这种限制虽然使得网络变得更容易学习，但在一定程度上也减弱了神经网络模型的能力。特别是在很多现实任务中，网络的输出不仅和当前时刻的输入相关，也和其过去一段时间的输出相关。此外，普通网络难以处理时序数据，比如视频、语音、文本等，时序数据的长度一般是不固定的，而前馈神经网络要求输入和输出的维数都是固定的，不能任意改变。因此，当处理这一类和时序相关的问题时，就需要一种能力更强的模型。

循环神经网络（Recurrent Neural Network，RNN）是一类具有短期记忆能力的神经网络。在循环神经网络中，神经元不但可以接受其它神经元的信息，也可以接受自身的信息，形成具有环路的网络结构。换句话说：神经元的输出可以在下一个时间步直接作用到自身（下一个时间步上，其输入不仅包含当前时间步的输入，还有上一个神经元的输出，即循环的含义，因此RNN是一种具有短期记忆的网络结构）

通过简化图，我们看到RNN比传统的神经网络多了一个循环圈，这个循环表示的就是在下一个时间步（Time Step，不同时刻，把输入展开，每个输入是不同的时间步上的）上会返回作为输入的一部分，我们把RNN在时间点上展开，得到的图形如下：

或者是：

在不同的时间步，RNN的输入都将与之前的时间状态有关， $t_n$ 时刻网络的输出结果是该时刻的输入和所有历史共同作用的结果，这就达到了对时间序列建模的目的。

RNN的不同表示和功能可以通过下图看出：

图1：固定长度的输入和输出 (e.g. 图像分类)
图2：序列输出 (e.g.图像转文字)
图3：数列输入 (e.g. 文本分类)
图4：异步的序列输入和输出(e.g.文本翻译).
图5：同步的序列输入和输出 (e.g. 根据视频的每一帧来对视频进行分类)

2. LSTM和GRU

2.1 LSTM的基础介绍

假如现在有这样一个需求，根据现有文本预测下一个词语，比如天上的云朵漂浮在__，通过间隔不远的位置就可以预测出来词语是天上，但是对于其他一些句子，可能需要被预测的词语在前100个词语之前，那么此时由于间隔非常大，随着间隔的增加可能会导致真实的预测值对结果的影响变的非常小，而无法非常好的进行预测（RNN中的长期依赖问题（long-Term Dependencies））

那么为了解决这个问题需要LSTM（Long Short-Term Memory网络）

LSTM是一种RNN特殊的类型，可以学习长期依赖信息。在很多问题上，LSTM都取得相当巨大的成功，并得到了广泛的应用。

一个LSMT的单元就是下图中的一个绿色方框中的内容：

其中 $\sigma$ 表示sigmod函数，其他符号的含义：

2.2 LSTM的核心

LSTM的核心在于单元（细胞）中的状态，也就是上图中最上面的那根线。

但是如果只有上面那一条线，那么没有办法实现信息的增加或者删除，所以在LSTM是通过一个叫做门的结构实现，门可以选择让信息通过或者不通过。

这个门主要是通过sigmoid和点乘（pointwise multiplication）实现的

C表示记忆，通过 $s i g m o i d$ 实现对记忆的修改，通过 $s i g m o i d$ 和 $C_{t-1}$ 点乘实现。 $s i g m o i d$ 的取值范围是在(0,1)之间，如果接近0表示不让任何信息通过，如果接近1表示所有的信息都会通过

2.3 逐步理解LSTM

2.3.1 遗忘门

遗忘门通过sigmoid函数来决定哪些信息会被遗忘

在下图就是 $h_{t-1}和x_t$ 进行合并（concat）之后乘上权重和偏置，通过sigmoid函数，输出0-1之间的一个值，这个值会和前一次的细胞状态( $C_{t-1}$ )进行点乘，从而决定遗忘或者保留

2.3.2 输入门

下一步就是决定哪些新的信息会被保留，这个过程有两步：

一个被称为输入门的sigmoid 层决定哪些信息会被更新
tanh会创造一个新的候选向量 $\widetilde{C}_{t}$ ，后续可能会被添加到细胞状态中

例如：

我昨天吃了苹果，今天我想吃菠萝，在这个句子中，通过遗忘门可以遗忘苹果,同时更新新的主语为菠萝

现在就可以更新旧的细胞状态 $C_{t-1}$ 为新的 $C_{ t }$ 了。

更新的构成很简单就是：

1. 旧的细胞状态和遗忘门的结果相乘
2. 然后加上输入门和tanh相乘的结果

2.3.3 输出门

最后，需要决定什么信息会被输出，也是一样这个输出经过变换之后会通过sigmoid函数的结果来决定那些细胞状态会被输出。

步骤如下：

前一次的输出和当前时间步的输入的组合结果通过sigmoid函数进行处理得到 $O_t$
更新后的细胞状态 $C_t$ 会经过tanh层的处理，把数据转化到(-1,1)的区间
tanh处理后的结果和 $O_t$ 进行相乘，把结果输出同时传到下一个LSTM的单元

三个输入和输出，输出为：输出、隐藏状态、细胞状态；输入为：前一次的隐藏状态，前一次的细胞状态，当前的输入

2.4 GRU，LSTM的变形

GRU(Gated Recurrent Unit),是一种LSTM的变形版本，它将遗忘和输入门组合成一个“更新门”。它还合并了单元状态和隐藏状态，并进行了一些其他更改，由于他的模型比标准LSTM模型简单，所以越来越受欢迎。

LSTM内容参考

3. 双向LSTM

单向的 RNN，是根据前面的信息推出后面的，但有时候只看前面的词是不够的，可能需要预测的词语和后面的内容也相关，那么此时需要一种机制，能够让模型不仅能够从前往后的具有记忆，还需要从后往前需要记忆。此时双向LSTM就可以帮助我们解决这个问题

由于是双向LSTM，所以每个方向的LSTM都会有一个输出，最终的输出会有2部分，所以往往需要concat的操作

循环神经网络实现文本情感分类

1. Pytorch中LSTM和GRU模块使用

1.1 LSTM介绍

LSTM和GRU都是由torch.nn提供

通过观察文档，可知LSMT的参数，

torch.nn.LSTM(input_size,hidden_size,num_layers,batch_first,dropout,bidirectional)

input_size：输入数据的形状即数据最后一个维度的长度，即embedding_dim
hidden_size：隐藏层神经元的数量，即每一层有多少个LSTM单元
num_layer ：即RNN的中LSTM单元的层数
batch_first：默认值为False，输入的数据需要[seq_len,batch,feature],如果为True，则为[batch,seq_len,feature]
dropout:dropout的比例，默认值为0。dropout是一种训练过程中让部分参数随机失活的一种方式，能够提高训练速度，同时能够解决过拟合的问题。这里是在LSTM的最后一层，对每个输出进行dropout
bidirectional：是否使用双向LSTM,默认是False

LSTM API
a. torch.nn提供
b. 实例化
	LSTM(input_size = embedding_dim，hidden_size = LSTM单元个数，num_layer = 层数，batch_first = 数据batch_size 是否在第一个维度)
c. output(h_n, c_n) = lstm(input, (h_0，c_0)) 
	i. input: [batch_size，seq_len，embedding_dim]
	ii. h_0 [num_layer * [1|2]，batch_size，hidden_size]，c_0形状同h_0
	iv. output [batch_size，seq_len，hidden_size]
	v.h_n [num_layer * [1|2]，batch_size，hidden_size]，c_n形状同h_n
d. output 把每个时间步上的结果，在seq_len这一维度进行了拼接
e. h_n 把不同层的隐藏状态，在第0个维度上进行了拼接

实例化LSTM对象之后,不仅需要传入数据，还需要前一次的h_0(前一次的隐藏状态)和c_0（前一次memory即细胞状态）

即：lstm(input,(h_0,c_0))

LSTM的默认输出为output, (h_n, c_n)

output：(seq_len, batch, num_directions * hidden_size)—>batch_first=False（num_direction：若bidirectional=True,num_direction=2;若bidirectional=False,num_direction=1）
h_n:(num_layers * num_directions, batch, hidden_size)
c_n: (num_layers * num_directions, batch, hidden_size)

1.2 LSTM使用示例

假设数据输入为 input ,形状是[10,20]，假设embedding的形状是[100,30]

则LSTM使用示例如下：

batch_size =10
seq_len = 20
embedding_dim = 30
word_vocab = 100
hidden_size = 18
num_layer = 2

#准备输入数据
input = torch.randint(low=0,high=100,size=(batch_size,seq_len))
#准备embedding
embedding  = torch.nn.Embedding(word_vocab,embedding_dim)
lstm = torch.nn.LSTM(embedding_dim,hidden_size,num_layer)

#进行mebed操作
embed = embedding(input) #[10,20,30]

#转化数据为batch_first=False
embed = embed.permute(1,0,2) #[20,10,30]

#初始化状态， 如果不初始化，torch默认初始值为全0
h_0 = torch.rand(num_layer,batch_size,hidden_size)
c_0 = torch.rand(num_layer,batch_size,hidden_size)
output,(h_1,c_1) = lstm(embed,(h_0,c_0))
#output [20,10,1*18]
#h_1 [2,10,18]
#c_1 [2,10,18]

输出如下

In [122]: output.size()
Out[122]: torch.Size([20, 10, 18])

In [123]: h_1.size()
Out[123]: torch.Size([2, 10, 18])

In [124]: c_1.size()
Out[124]: torch.Size([2, 10, 18])

通过前面的学习，我们知道，最后一次的h_1应该和output的最后一个time step的输出是一样的

通过下面的代码，我们来验证一下：

In [179]: a = output[-1,:,:]

In [180]: a.size()
Out[180]: torch.Size([10, 18])

In [183]: b.size()
Out[183]: torch.Size([10, 18])
In [184]: a == b
Out[184]:
tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]],
       dtype=torch.uint8)

import torch.nn as nn
import torch

batch_size = 10  # 句子数量
seq_len = 20  # 句子长度
vocab_size = 100  # 词典数量
embedding_dim = 30  # 用长度为30的向量表示一个词语
hidden_size = 18  # 每层18个隐藏lstm单元
num_layer = 1  # RNN的中LSTM单元的层数


# 构造一个batch 数据
input = torch.randint(low = 0, high = 100, size = [batch_size, seq_len])
# 数据经过embedding 处理
embedding = nn.Embedding(vocab_size, embedding_dim)
input_embedded = embedding(input) # [batch_size, seq_lem] --> [batch_size, seq_len, embedding_dim]

# 把embedding后的数据传入LSTM
lstm = nn.LSTM(input_size = embedding_dim, hidden_size = hidden_size, num_layers = num_layer, batch_first = True)
# output, (h_n, c_n) = lstm(input_embedded, (h_0, c_0)) (h_0, c_0)自动初始化，可以不传
output, (h_n, c_n) = lstm(input_embedded)
print(output)
print(h_n)
print(c_n)
print('*' * 100)
print(output.size())  # [batch_size, seq_len, hidden_size]
print(h_n.size())  # [num_layer * [1/2], batch_size, hidden_size]
print(c_n.size())  # [num_layer * [1/2], batch_size, hidden_size]

# 获取最后一个时间步的输出
last_output = output[:, -1, :]
print(last_output)
# 获取最后一次的hidden_state
last_hidden = h_n[-1, :, :]
print(last_hidden)
# output 把每个时间步上的结果，在seq_len这一维度进行了拼接
# h_n 把不同层的隐藏状态，在第0个维度上进行了拼接
print(last_output == last_hidden)

1.3 GRU的使用示例

GRU模块torch.nn.GRU，和LSTM的参数相同，含义相同，具体可参考文档

但是输入只剩下gru(input,h_0)，输出为output, h_n

其形状为：

output:(seq_len, batch, num_directions * hidden_size)
h_n:(num_layers * num_directions, batch, hidden_size)

import torch.nn as nn
import torch

batch_size = 10  # 句子数量
seq_len = 20  # 句子长度
vocab_size = 100  # 词典数量
embedding_dim = 30  # 用长度为30的向量表示一个词语
hidden_size = 18  # 每层18个隐藏的lstm单元
num_layer = 1  # rnn中的lstm单元的层数


# 构造一个batch数据
input = torch.randint(low = 0, high = 100, size = [batch_size, seq_len])
# embedding处理,实例化
embedding = nn.Embedding(vocab_size, embedding_dim)
# 进行embedding处理
embedded_input = embedding(input)

#  把embedding后的数据传入GRU
gru = nn.GRU(input_size = embedding_dim, hidden_size = hidden_size, num_layers = num_layer, batch_first = True)
output, h_n= gru(embedded_input)
print(output)
print(h_n)
print(output.size())  # [batch_size, seq_len] ---> [batch_size, seq_len,  num_directions * hidden_size]
print(h_n.size())  # [num_layer*[1/2] , batch_size, hidden_size]

# 获取最后一个时间步的输出
last_output = output[:, -1, :]
print(last_output)
# 获取最后一次的hidden_state
last_hidden = h_n[-1, :, :]
print(last_hidden)
print(last_output == last_hidden)

1.4 双向LSTM

如果需要使用双向LSTM，则在实例化LSTM的过程中，需要把LSTM中的bidriectional设置为True，同时h_0和c_0使用num_layer*2

观察效果，输出为

batch_size =10 #句子的数量
seq_len = 20  #每个句子的长度
embedding_dim = 30  #每个词语使用多长的向量表示
word_vocab = 100  #词典中词语的总数
hidden_size = 18  #隐层中lstm的个数
num_layer = 2  #多少个隐藏层

input = torch.randint(low=0,high=100,size=(batch_size,seq_len))
embedding  = torch.nn.Embedding(word_vocab,embedding_dim)
lstm = torch.nn.LSTM(embedding_dim,hidden_size,num_layer,bidirectional=True)

embed = embedding(input) #[10,20,30]

#转化数据为batch_first=False
embed = embed.permute(1,0,2) #[20,10,30]
h_0 = torch.rand(num_layer*2,batch_size,hidden_size)
c_0 = torch.rand(num_layer*2,batch_size,hidden_size)
output,(h_1,c_1) = lstm(embed,(h_0,c_0))

In [135]: output.size()
Out[135]: torch.Size([20, 10, 36])

In [136]: h_1.size()
Out[136]: torch.Size([4, 10, 18])

In [137]: c_1.size()
Out[137]: torch.Size([4, 10, 18])

在单向LSTM中，最后一个time step的输出的前hidden_size个和最后一层隐藏状态h_1的输出相同，那么双向LSTM呢？

双向LSTM中：

output：按照正反计算的结果顺序在第2个维度进行拼接，正向第一个拼接反向的最后一个输出

hidden state:按照得到的结果在第0个维度进行拼接，正向第一个之后接着是反向第一个

前向的LSTM中，最后一个time step的输出的前hidden_size个和最后一层向前传播h_1的输出相同

示例：

#-1是前向LSTM的最后一个，前18是前hidden_size个
In [188]: a = output[-1,:,:18]  #前项LSTM中最后一个time step的output

In [189]: b = h_1[-2,:,:]  #倒数第二个为前向

In [190]: a.size()
Out[190]: torch.Size([10, 18])

In [191]: b.size()
Out[191]: torch.Size([10, 18])

In [192]: a == b
Out[192]:
tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]],
       dtype=torch.uint8)

后向LSTM中，最后一个time step的输出的后hidden_size个和最后一层后向传播的h_1的输出相同

示例

#0 是反向LSTM的最后一个，后18是后hidden_size个
In [196]: c = output[0,:,18:]  #后向LSTM中的最后一个输出

In [197]: d = h_1[-1,:,:] #后向LSTM中的最后一个隐藏层状态

In [198]: c == d
Out[198]:
tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]],
       dtype=torch.uint8)

import torch.nn as nn
import torch

batch_size = 10 # 句子数量
seq_len = 20  # 句子长度
vocab_size = 100  # 词典数量
num_layer = 2  # RNN中LSTM层数
hidden_size = 18  # 每个隐藏层LSTM的单元数量
embedding_dim = 30  # 用长度为30的向量表示一个词语

# 构造batch数据
input = torch.randint(low = 0, high = 100, size = [batch_size, seq_len])

# 进行embedding处理，实例化
embedding = nn.Embedding(vocab_size, embedding_dim)
# 进行embedding处理数据
input_embedded = embedding(input)

# 实例化lstm
lstm = nn.LSTM(input_size = embedding_dim, hidden_size = hidden_size, num_layers = num_layer, batch_first = True,
               bidirectional = True)  # bidirectional = True 双向LSTM

output, (h_n, c_n) = lstm(input_embedded)
print(output.size())  # [batch_size, seq_len, hidden_size * num_direction[1/2]]
print(h_n.size())  # [num_direction[1/2] * num_layer, batch_size, hidden_size]
print(c_n.size())


# 双向的LSTM中，最上层的正向的最后一个输出
o1 = output[:,-1,:hidden_size]  # 正向的最后一个输出
o2 = output[:,0,hidden_size:]   # 反向最后一个输出

# 双向LSTM中，最上层正向的h_n
h1 = h_n[-2,:,:]  # 最上层正向
h2 = h_n[-1,:,:]  # 最上层反向
print(o1.eq(h1))

1.4 LSTM和GRU的使用注意点

第一次调用之前，需要初始化隐藏状态，如果不初始化，默认创建全为0的隐藏状态
往往会使用LSTM or GRU 的输出的最后一维的结果，来代表LSTM、GRU对文本处理的结果，其形状为[batch, hidden_size]。
1. 并不是所有模型都会使用最后一维的结果
2. 如果实例化LSTM的过程中，batch_first=False,则output[-1] or output[-1,:,:]可以获取最后一维
3. 如果实例化LSTM的过程中，batch_first=True,则output[:,-1,:]可以获取最后一维
如果结果是(seq_len, batch_size, num_directions * hidden_size),需要把它转化为(batch_size,seq_len, num_directions * hidden_size)的形状，不能够使用view等变形的方法，需要使用output.permute(1,0,2)，即交换0和1轴，实现上述效果
使用双向LSTM的时候，往往会分别使用每个方向最后一次的output，作为当前数据经过双向LSTM的结果
- 即：torch.cat([h_1[-2,:,:],h_1[-1,:,:]],dim=-1)
- 最后的表示的size是[batch_size,hidden_size*2]
上述内容在GRU中同理

2. 使用LSTM完成文本情感分类

在前面，我们使用了word embedding去实现了toy级别的文本情感分类，那么现在我们在这个模型中添加上LSTM层，观察分类效果。

为了达到更好的效果，对之前的模型做如下修改

MAX_LEN = 200
构建dataset的过程，把数据转化为2分类的问题，pos为1，neg为0，否则25000个样本完成10个类别的划分数据量是不够的
在实例化LSTM的时候，使用dropout=0.5，在model.eval()的过程中，dropout自动会为0(在训练时以一定的概率使神经元失活，实际上就是让对应神经元的输出为0)

2.1 修改模型

class IMDBLstmmodel(nn.Module):
    def __init__(self):
        super(IMDBLstmmodel,self).__init__()
        self.hidden_size = 64
        self.embedding_dim = 200
        self.num_layer = 2
        self.bidriectional = True
        self.bi_num = 2 if self.bidriectional else 1
        self.dropout = 0.5
        #以上部分为超参数，可以自行修改

        self.embedding = nn.Embedding(len(ws),self.embedding_dim,padding_idx=ws.PAD) #[N,300]
        self.lstm = nn.LSTM(self.embedding_dim,self.hidden_size,self.num_layer,bidirectional=True,dropout=self.dropout)
        #使用两个全连接层，中间使用relu激活函数
        self.fc = nn.Linear(self.hidden_size*self.bi_num,20)
        self.fc2 = nn.Linear(20,2)


    def forward(self, x):
        x = self.embedding(x)
        x = x.permute(1,0,2) #进行轴交换
        h_0,c_0 = self.init_hidden_state(x.size(1))
        _,(h_n,c_n) = self.lstm(x,(h_0,c_0))

        #只要最后一个lstm单元处理的结果，这里多去的hidden state
        out = torch.cat([h_n[-2, :, :], h_n[-1, :, :]], dim=-1)
        out = self.fc(out)
        out = F.relu(out)
        out = self.fc2(out)
        return F.log_softmax(out,dim=-1)

    def init_hidden_state(self,batch_size):
        h_0 = torch.rand(self.num_layer * self.bi_num, batch_size, self.hidden_size).to(device)
        c_0 = torch.rand(self.num_layer * self.bi_num, batch_size, self.hidden_size).to(device)
        return h_0,c_0

2.2 完成训练和测试代码

为了提高程序的运行速度，可以考虑把模型放在gup上运行，那么此时需要处理一下几点：

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
除了上述修改外，涉及计算的所有tensor都需要转化为CUDA的tensor
1. 初始化的h_0,c_0
2. 训练集和测试集的input,traget
在最后可以通过tensor.cpu()转化为torch的普通tensor

train_batch_size = 64
test_batch_size = 5000
# imdb_model = IMDBModel(MAX_LEN) #基础model
imdb_model = IMDBLstmmodel().to(device) #在gpu上运行，提高运行速度
# imdb_model.load_state_dict(torch.load("model/mnist_net.pkl"))
optimizer = optim.Adam(imdb_model.parameters())
criterion = nn.CrossEntropyLoss()

def train(epoch):
    mode = True
    imdb_model.train(mode)
    train_dataloader =get_dataloader(mode,train_batch_size)
    for idx,(target,input,input_lenght) in enumerate(train_dataloader):
        target = target.to(device)
        input = input.to(device)
        optimizer.zero_grad()
        output = imdb_model(input)
        loss = F.nll_loss(output,target) #traget需要是[0,9]，不能是[1-10]
        loss.backward()
        optimizer.step()
        if idx %10 == 0:
            pred = torch.max(output, dim=-1, keepdim=False)[-1]
            acc = pred.eq(target.data).cpu().numpy().mean()*100.

            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}\t ACC: {:.6f}'.format(epoch, idx * len(input), len(train_dataloader.dataset),
                       100. * idx / len(train_dataloader), loss.item(),acc))

            torch.save(imdb_model.state_dict(), "model/mnist_net.pkl")
            torch.save(optimizer.state_dict(), 'model/mnist_optimizer.pkl')
            
 def test():
    mode = False
    imdb_model.eval()
    test_dataloader = get_dataloader(mode, test_batch_size)
    with torch.no_grad():
        for idx,(target, input, input_lenght) in enumerate(test_dataloader):
            target = target.to(device)
            input = input.to(device)
            output = imdb_model(input)
            test_loss  = F.nll_loss(output, target,reduction="mean")
            pred = torch.max(output,dim=-1,keepdim=False)[-1]
            correct = pred.eq(target.data).sum()
            acc = 100. * pred.eq(target.data).cpu().numpy().mean()
            print('idx: {} Test set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\n'.format(idx,test_loss, correct, target.size(0),acc))
            
 if __name__ == "__main__":
    test()
    for i in range(10):
        train(i)
        test()

2.3 模型训练的最终输出

...
Train Epoch: 9 [20480/25000 (82%)]	Loss: 0.017165	 ACC: 100.000000
Train Epoch: 9 [21120/25000 (84%)]	Loss: 0.021572	 ACC: 98.437500
Train Epoch: 9 [21760/25000 (87%)]	Loss: 0.058546	 ACC: 98.437500
Train Epoch: 9 [22400/25000 (90%)]	Loss: 0.045248	 ACC: 98.437500
Train Epoch: 9 [23040/25000 (92%)]	Loss: 0.027622	 ACC: 98.437500
Train Epoch: 9 [23680/25000 (95%)]	Loss: 0.097722	 ACC: 95.312500
Train Epoch: 9 [24320/25000 (97%)]	Loss: 0.026713	 ACC: 98.437500
Train Epoch: 9 [15600/25000 (100%)]	Loss: 0.006082	 ACC: 100.000000
idx: 0 Test set: Avg. loss: 0.8794, Accuracy: 4053/5000 (81.06%)
idx: 1 Test set: Avg. loss: 0.8791, Accuracy: 4018/5000 (80.36%)
idx: 2 Test set: Avg. loss: 0.8250, Accuracy: 4087/5000 (81.74%)
idx: 3 Test set: Avg. loss: 0.8380, Accuracy: 4074/5000 (81.48%)
idx: 4 Test set: Avg. loss: 0.8696, Accuracy: 4027/5000 (80.54%)

可以看到模型的测试准确率稳定在81%左右。

可以把上述代码改为GRU，或者多层LSTM继续尝试，观察效果

完整代码2

│  dataset.py
│  lib.py
│  main.py
│  model.py
│  model_gpu.py
│  word_sequence.py
│  __init__.py
│
├─data
├─model
│      model.pkl
│      optimizer.pkl
│      ws.pkl

model.py

"""
定义模型
模型优化方法：
# 为使得结果更好 添加一个新的全连接层，作为输出，激活函数处理
# 把双向LSTM的output传给一个单向LSTM再进行处理

lib.max_len = 200
lib.embedding_dim = 100  # 用长度为100的向量表示一个词
lib.hidden_size = 128  # 每个隐藏层中LSTM单元个数
lib.num_layer = 2  # 隐藏层数量
lib.bidirectional = True  # 是否双向LSTM
lib.dropout = 0.3  # 在训练时以一定的概率使神经元失活，实际上就是让对应神经元的输出为0
lib.device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
"""
import  torch.nn as nn
from lib import ws, max_len
import torch.nn.functional as F
from torch.optim import Adam
from dataset import get_dataloader
from tqdm import tqdm
import torch
import numpy as np
import lib
import os


class Mymodel(nn.Module):
    def __init__(self):
        super(Mymodel, self).__init__()
        # nn.Embedding(num_embeddings - 词嵌入字典大小即一个字典里要有多少个词，embedding_dim - 每个词嵌入向量的大小。)
        self.embedding = nn.Embedding(len(ws), 100)
        # 加入LSTM
        self.lstm = nn.LSTM(input_size=lib.embedding_dim, hidden_size=lib.hidden_size, num_layers=lib.num_layer,
                            batch_first=True, bidirectional=lib.bidirectional, dropout=lib.dropout)
        self.fc = nn.Linear(lib.hidden_size * 2, 2)


    def forward(self, input):
        """
        :param input: 形状[batch_size, max_len]
        :return:
        """
        x = self.embedding(input)  # 进行embedding，形状[batch_size, max_len, 100]


        # x [batch_size, max_len, num_direction*hidden_size]
        # h_n[num_direction * num_layer, batch_size, hidden_size]
        x,(h_n, c_n) = self.lstm(x)
        # 获取两个方向最后一次的output(正向最后一个和反向第一个)进行concat
        # output = x[:,-1,:hidden_size]   前向，等同下方
        output_fw = h_n[-2,:,:]  #  正向最后一次输出
        # output = x[:,0,hidden_size:]   反向，等同下方
        output_bw = h_n[-1,:,:]  # 反向最后一次输出

        output = torch.cat([output_fw, output_bw], dim=-1)  # [batch_size, hidden_size*num_direction]

        out = self.fc(output)

        return F.log_softmax(out, dim=-1)

model = Mymodel()
optimizer = Adam(model.parameters(), lr = 0.01)
if os.path.exists('./model/model.pkl'):
    model.load_state_dict(torch.load('./model/model.pkl'))
    optimizer.load_state_dict(torch.load('./model/optimizer.pkl'))


# 训练
def train(epoch):
    for idx, (input, target) in enumerate(get_dataloader(train = True)):
        output = model(input)
        optimizer.zero_grad()
        loss = F.nll_loss(output, target)
        loss.backward()
        optimizer.step()
        print(loss.item())
        print('当前第%d轮,idx为%d 损失为:%lf, ' % (epoch, idx,loss.item()))

        # 保存模型
        if idx%100 == 0:
            torch.save(model.state_dict(), './model/model.pkl')
            torch.save(optimizer.state_dict(), './model/optimizer.pkl')
            
# 评估
def test():
    acc_list = []
    loss_list = []
    # 开启模型评估模式
    model.eval()
    # 获取测试集数据
    test_dataloader = get_dataloader(train = False)
    # tqdm(total = 总数,ascii = #,desc=描述)
    for idx,(input, target) in tqdm(enumerate(test_dataloader),total = len(test_dataloader),ascii = True,desc='评估：'):
        with torch.no_grad():
            output = model(input)
            # 计算当前损失
            cur_loss = F.nll_loss(output, target)
            loss_list.append(cur_loss)
            pred = output.max(dim = -1)[-1]
            # 计算当前准确率
            cur_acc = pred.eq(target).float().mean()
            acc_list.append(cur_acc)
    print('准确率为:%lf, 损失为:%lf' % (np.mean(acc_list), np.mean(loss_list)))


if __name__ == '__main__':
    for i in tqdm(range(10)):
        train(i)
    test()

dataset.py

import torch
from torch.utils.data import Dataset, DataLoader
import os
import re

"""
完成数据集准备
"""
TRAIN_PATH = r"E:\data\aclImdb\train"
TEST_PATH = r"E:\data\aclImdb\test"


# 分词
def tokenlize(content):
    content = re.sub(r"<.*?>", " ", content)
    filters = ['!','"','#','$','%','&','\(','\)','\*','\+',',','-','\.','/',':',';','<','=','>','\?','@'
        ,'\[','\\','\]','^','_','`','\{','\|','\}','~','\t','\n','\x97','\x96','”','“',]
    content = re.sub("|".join(filters), " ", content)
    tokens = [i.strip().lower() for i in content.split()]
    return tokens


class ImbdDateset(Dataset):
    def __init__(self, train = True):
        self.train_data_path = TRAIN_PATH
        self.test_data_path = TEST_PATH
        # 通过train和data_path控制读取train或者test数据集
        data_path = self.train_data_path if train else self.test_data_path
        # 把所有文件名放入列表
        # temp_data_path = [data_path + '/pos', data_path + '/neg']
        temp_data_path = [os.path.join(data_path , 'pos'), os.path.join(data_path , 'neg')]
        self.total_file_path = []  # 所有pos,neg评论文件的path
        # 获取每个文件名字，并拼接路径
        for path in temp_data_path:
            file_name_list = os.listdir(path)
            file_path_list = [os.path.join(path, i) for i in file_name_list if i.endswith('.txt')]
            self.total_file_path.extend(file_path_list)


    def __getitem__(self, index):
        # 获取index的path
        file_path = self.total_file_path[index]
        # 获取label
        label_str = file_path.split('\\')[-2]
        label = 0 if label_str =='neg' else 1
        # 获取content
        tokens = tokenlize(open(file_path, errors='ignore').read())
        return tokens, label


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

def get_dataloader(train = True):
    imdb_dataset = ImbdDateset(train)
    data_loader = DataLoader(imdb_dataset, shuffle = True, batch_size = 128, collate_fn = collate_fn)
    return data_loader

# 重新定义collate_fn
def collate_fn(batch):
    """
    :param batch: (一个__getitem__[tokens, label], 一个__getitem__[tokens, label],..., batch_size个)
    :return:
    """
    content, label = list(zip(*batch))
    from lib import ws, max_len
    content = [ws.transform(i, max_len = max_len) for i in content]
    content = torch.LongTensor(content)
    label = torch.LongTensor(label)
    return content, label


if __name__ == '__main__':
    for idx, (input, target) in enumerate(get_dataloader()):
        print(idx)
        print(input)
        print(target)
        break

word_squence.py

import numpy as np
"""
构建词典,实现方法把句子转换为序列,和其翻转
"""

class Word2Sequence(object):
    # 2个特殊类属性，标记特殊字符和填充标记
    UNK_TAG = 'UNK'
    PAD_TAG = 'PAD'

    UNK = 0
    PAD = 1


    def __init__(self):
        self.dict = {
     
            # 保存词语和对应的数字
            self.UNK_TAG : self.UNK,
            self.PAD_TAG : self.PAD
        }
        self.count = {
     }  # 统计词频


    def fit(self, sentence):
        """
        把单个句子保存到dict中
        :param sentence: [word1, word2 , ... , ]
        :return:
        """
        for word in sentence:
            # 对word出现的频率进行统计，当word不在sentence时，返回值是0，当word在sentence中时，返回+1，以此进行累计计数
            self.count[word] = self.count.get(word, 0) + 1



    def build_vocab(self, min = 5, max = None, max_features = None):
        """
        生成词典
        :param min:最小词频数
        :param max:最大词频数
        :param max_feature:一共保留多少词语
        :return:
        """
        # 删除count < min 的词语,即保留count > min 的词语
        if min is not None:
            self.count = {
     word : value for word, value in self.count.items() if value > min}
        # 删除count > min 的词语,即保留count < max 的词语
        if max is not None:
            self.count = {
     word : value for word, value in self.count.items() if value < max}
        # 限制保留的词语数
        if max_features is not None:
            # sorted 返回一个列表[(key1, value1), (key2, value2),...]，True为升序
            temp = sorted(self.count.items(), key = lambda x : x[-1], reverse = True)[:max_features]
            self.count = dict(temp)
            for word in self.count:
                self.dict[word] = len(self.dict)


        # 得到一个翻转的dict字典
        # zip方法要比{value: word for word, value in self.dict.items()}快
        self.inverse_dict = dict(zip(self.dict.values(), self.dict.keys()))


    def transform(self, sentence, max_len = None):
        """
        把句子转换为序列
        :param sentence: [word1, word2...]
        :param max_len: 对句子进行填充或者裁剪
        :return:
        """
        if max_len is not None:
            # 句子长度小于最大长度，进行填充
            if max_len > len(sentence):
                sentence = sentence + [self.PAD_TAG] * (max_len - len(sentence))
            # 句子长度大于最大长度，进行裁剪
            if max_len < len(sentence):
                sentence = sentence[:max_len]
        # for word in sentence:
        #     self.dict.get(word, self.UNK)
        # 字典的get(key, default=None) 如果指定键不存在，则返回默认值None。
        return [self.dict.get(word, self.UNK) for word in sentence]


    def inverse_transform(self, indices):
        """
        把序列转换为句子
        :param indices: [1, 2, 3, ...]
        :return:
        """
        return [self.inverse_dict.get(idx) for idx in indices]


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


if __name__ == '__main__':
    ws = Word2Sequence()
    ws.fit(["我", "是", "我"])
    ws.fit(["我", "是", "谁"])
    ws.build_vocab(min = 1, max_features=5)
    print(ws.dict)
    ret = ws.transform(['我', '爱', '北京'], max_len=10)
    print(ret)
    print(ws.inverse_transform(ret))

lib.py

import pickle
import torch

ws = pickle.load(open('./model/ws.pkl', 'rb'))

max_len = 200
embedding_dim = 100  # 用长度为100的向量表示一个词
hidden_size = 128  # 每个隐藏层中LSTM单元个数
num_layer = 2  # 隐藏层数量
bidirectional = True  # 是否双向LSTM
dropout = 0.3  # 在训练时以一定的概率使神经元失活，实际上就是让对应神经元的输出为0

device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')

main.py

# 由于pickle特殊性，需要在此导入Word2Sequence
from word_sequence import Word2Sequence
import pickle
import os
from dataset import tokenlize
from tqdm import tqdm  # 显示当前迭代进度

TRAIN_PATH = r"E:\data\aclImdb\train"


if __name__ == '__main__':
    ws = Word2Sequence()
    temp_data_path = [os.path.join(TRAIN_PATH, 'pos'), os.path.join(TRAIN_PATH, 'neg')]
    for data_path in temp_data_path:
        # 获取每一个文件的路径
        file_paths = [os.path.join(data_path, file_name) for file_name in os.listdir(data_path)]
        for file_path in tqdm(file_paths):
            sentence = tokenlize(open(file_path, errors = 'ignore').read())
            ws.fit(sentence)
    ws.build_vocab(max = 10, max_features = 10000)
    pickle.dump(ws, open('./model/ws.pkl', 'wb'))
    print(len(ws.dict))

GPU版本

"""
定义模型
模型优化方法：
# 为使得结果更好 添加一个新的全连接层，作为输出，激活函数处理
# 把双向LSTM的output传给一个单向LSTM再进行处理

lib.max_len = 200
lib.embedding_dim = 100  # 用长度为100的向量表示一个词
lib.hidden_size = 128  # 每个隐藏层中LSTM单元个数
lib.num_layer = 2  # 隐藏层数量
lib.bidirectional = True  # 是否双向LSTM
lib.dropout = 0.3  # 在训练时以一定的概率使神经元失活，实际上就是让对应神经元的输出为0
lib.device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
"""
import  torch.nn as nn
from lib import ws, max_len
import torch.nn.functional as F
from torch.optim import Adam
from dataset import get_dataloader
from tqdm import tqdm
import torch
import numpy as np
import lib
import os

class Mymodel(nn.Module):
    def __init__(self):
        super(Mymodel, self).__init__()
        # nn.Embedding(num_embeddings - 词嵌入字典大小即一个字典里要有多少个词，embedding_dim - 每个词嵌入向量的大小。)
        self.embedding = nn.Embedding(len(ws), 100)
        # 加入LSTM
        self.lstm = nn.LSTM(input_size=lib.embedding_dim, hidden_size=lib.hidden_size, num_layers=lib.num_layer,
                            batch_first=True, bidirectional=lib.bidirectional, dropout=lib.dropout)
        self.fc = nn.Linear(lib.hidden_size * 2, 2)

    def forward(self, input):
        """
        :param input: 形状[batch_size, max_len]
        :return:
        """
        x = self.embedding(input)  # 进行embedding，形状[batch_size, max_len, 100]


        # x [batch_size, max_len, num_direction*hidden_size]
        # h_n[num_direction * num_layer, batch_size, hidden_size]
        x,(h_n, c_n) = self.lstm(x)
        # 获取两个方向最后一次的output(正向最后一个和反向第一个)进行concat
        # output = x[:,-1,:hidden_size]   前向，等同下方
        output_fw = h_n[-2,:,:]  #  正向最后一次输出
        # output = x[:,0,hidden_size:]   反向，等同下方
        output_bw = h_n[-1,:,:]  # 反向最后一次输出

        output = torch.cat([output_fw, output_bw], dim=-1)  # [batch_size, hidden_size*num_direction]

        out = self.fc(output)
        return F.log_softmax(out, dim=-1)


model = Mymodel().to(lib.device)
optimizer = Adam(model.parameters(), lr = 0.01)
if os.path.exists('./model/model.pkl'):
    model.load_state_dict(torch.load('./model/model.pkl'))
    optimizer.load_state_dict(torch.load('./model/optimizer.pkl'))


# 训练
def train(epoch):
    for idx, (input, target) in enumerate(get_dataloader(train = True)):
        input = input.to(lib.device)
        target = target.to(lib.device)
        output = model(input)
        optimizer.zero_grad()
        loss = F.nll_loss(output, target)
        loss.backward()
        optimizer.step()
        print(loss.item())
        print('当前第%d轮,idx为%d 损失为:%lf, ' % (epoch, idx,loss.item()))

        # 保存模型
        if idx%100 == 0:
            torch.save(model.state_dict(), './model/model.pkl')
            torch.save(optimizer.state_dict(), './model/optimizer.pkl')

# 评估
def test():
    acc_list = []
    loss_list = []
    # 开启模型评估模式
    model.eval()
    # 获取测试集数据
    test_dataloader = get_dataloader(train = False)
    for idx,(input, target) in tqdm(enumerate(test_dataloader),total = len(test_dataloader),ascii = True,desc='评估：'):
        input = input.to(lib.device)
        target = target.to(lib.device)
        with torch.no_grad():
            output = model(input)
            # 计算当前损失
            cur_loss = F.nll_loss(output, target)
            loss_list.append(cur_loss.cpu().item())
            pred = output.max(dim = -1)[-1]
            # 计算当前准确率
            cur_acc = pred.eq(target).float().mean()
            acc_list.append(cur_acc.cpu().item())
    print('准确率为:%lf, 损失为:%lf' % (np.mean(acc_list), np.mean(loss_list)))


if __name__ == '__main__':
    for i in tqdm(range(10)):
        train(i)
    test()

Pytorch中的序列化容器

1. 梯度消失和梯度爆炸

梯度消失:梯度太小，无法进行参数更新，梯度小到数据类型无法表示出现Nan
梯度爆炸:梯度太大，梯度大到数据类型无法表示出现Nan
解决方法：1、使用优化的梯度下降算法；2、替换激活函数；3、使用batch Normalization(序列化容器)
batch Normalization: 加速模型训练，把参数规范化处理，让参数计算的梯度不会过小

1.1 梯度消失

假设我们有四层极简神经网络：每层只有一个神经元

$获取 w 1 的梯度有： ▽ w 1 = x 1 * f (a 1) ’ * w 2 * f (b 1) ’ * w 3 * ▽ o u t$

假设我们使用sigmoid激活函数，即f为sigmoid函数，sigmoid的导数如下图

假设每层都取得sigmoid导函数的最大值1/4，那么在反向传播时， $X 1 = 0.5, w 1 = w 2 = w 3 = 0.5 $

$\nabla w1< \frac{1}{2} * \frac{1}{4}* \frac{1}{2}* \frac{1}{4}*\frac{1}{2}*\nabla out = \frac{1}{2^7} \nabla out$

当权重初始过小或使用易饱和神经元(sigmoid,tanh，) sigmoid在y=0,1处梯度接近0，而无法更新参数，时神经网络在反向传播时也会呈现指数倍缩小，产生“消失”现象。

1.2 梯度爆炸

假设 $X 2 = 2, w 1 = w 2 = w 3 = 2 $

当权重初始过大时，梯度神经网络在反向传播时也会呈现指数倍放大，产生“爆炸”现象。

1.3 解决梯度消失或者梯度爆炸的经验

替换易训练神经元
改进梯度优化算法：使用adam等算法
使用batch normalization

2. `nn.Sequential`

nn.Sequential是一个有序的容器，其中传入的是构造器类(各种用来处理input的类)，最终input会被Sequential中的构造器类依次执行，nn.Sequential会自动完成forward函数的创建

例如：

layer = nn.Sequential(
            nn.Linear(input_dim, n_hidden_1), 
            nn.ReLU(True)， #inplace=False 是否对输入进行就地修改，默认为False
            nn.Linear(n_hidden_1, n_hidden_2)，
            nn.ReLU(True)，
            nn.Linear(n_hidden_2, output_dim) # 最后一层不需要添加激活函数
             )

在上述就够中，可以直接调用layer(x)，得到输出

x的被执行顺序就是Sequential中定义的顺序：

被隐层1执行，形状变为[batch_size,n_hidden_1]
被relu执行，形状不变
被隐层2执行，形状变为[batch_size,n_hidden_2]
被relu执行，形状不变
被最后一层执行，形状变为[batch_size,output_dim]

3. `nn.BatchNorm1d`

batch normalization 翻译成中文就是批规范化，即在每个batch训练的过程中，对参数进行归一化的处理，从而达到加快训练速度的效果。

以sigmoid激活函数为例，他在反向传播的过程中，在值为0,1的时候，梯度接近0，导致参数被更新的幅度很小，训练速度慢。但是如果对数据进行归一化之后，就会尽可能的把数据拉倒[0-1]的范围，从而让参数更新的幅度变大，提高训练的速度。

batchNorm一般会放到激活函数之后，即对输入进行激活处理之后再进入batchNorm

layer = nn.Sequential(
            nn.Linear(input_dim, n_hidden_1),
    		
            nn.ReLU(True)， 
    		nn.BatchNorm1d(n_hidden_1)
    
            nn.Linear(n_hidden_1, n_hidden_2)，
            nn.ReLU(True)，
    		nn.BatchNorm1d(n_hidden_2)

            nn.Linear(n_hidden_2, output_dim) 
             )

4. `nn.Dropout`

dropout在前面已经介绍过，可以理解为对参数的随机失活

增加模型的稳健性
可以解决过拟合的问题（增加模型的泛化能力）
可以理解为训练后的模型是多个模型的组合之后的结果，类似随机森林。

layer = nn.Sequential(
            nn.Linear(input_dim, n_hidden_1),
            nn.ReLU(True)， 
    		nn.BatchNorm1d(n_hidden_1)
    		nn.Dropout(0.3) #0.3 为dropout的比例，默认值为0.5
    
            nn.Linear(n_hidden_1, n_hidden_2)，
            nn.ReLU(True)，
    		nn.BatchNorm1d(n_hidden_2)
    		nn.Dropout(0.3)
    
            nn.Linear(n_hidden_2, output_dim) 
             )

你可能感兴趣的:(笔记,rnn,lstm,深度学习,神经网络,自然语言处理)

机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
《投行人生》读书笔记小蘑菇的树洞
《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数广龙宇一起学Rust #Rust设计模式 rust 设计模式开发语言
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
git常用命令笔记咩酱-小羊 git 笔记
###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
将cmd中命令输出保存为txt文本文件落难Coder Windows cmd window
最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
509. 斐波那契数(每日一题) lzyprime
lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
拥有断舍离的心态，过精简生活--《断舍离》读书笔记爱吃丸子的小樱桃
不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
四章-32-点要素的聚合彩云飘过
本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
高端密码学院笔记285 柚子_b4b4
高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
探索OpenAI和LangChain的适配器集成：轻松切换模型提供商 nseejrukjhad langchain easyui 前端 python
#探索OpenAI和LangChain的适配器集成：轻松切换模型提供商##引言在人工智能和自然语言处理的世界中，OpenAI的模型提供了强大的能力。然而，随着技术的发展，许多人开始探索其他模型以满足特定需求。LangChain作为一个强大的工具，集成了多种模型提供商，通过提供适配器，简化了不同模型之间的转换。本篇文章将介绍如何使用LangChain的适配器与OpenAI集成，以便轻松切换模型提供商
使用Apify加载Twitter消息以进行微调的完整指南 nseejrukjhad twitter easyui 前端 python
#使用Apify加载Twitter消息以进行微调的完整指南##引言在自然语言处理领域，微调模型以适应特定任务是提升模型性能的常见方法。本文将介绍如何使用Apify从Twitter导出聊天信息，以便进一步进行微调。##主要内容###使用Apify导出推文首先，我们需要从Twitter导出推文。Apify可以帮助我们做到这一点。通过Apify的强大功能，我们可以批量抓取和导出数据，适用于各类应用场景。
深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具 nseejrukjhad 数据库 python
深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
Day17笔记-高阶函数 ~在杰难逃~ Python 笔记 python 开发语言 pycharm 数据分析
高阶函数【重点掌握】函数的本质：函数是一个变量，函数名是一个变量名，一个函数可以作为另一个函数的参数或返回值使用如果A函数作为B函数的参数，B函数调用完成之后，会得到一个结果，则B函数被称为高阶函数常用的高阶函数：map(),reduce(),filter(),sorted()1.map()map(func,iterable)，返回值是一个iterator【容器，迭代器】func:函数iterab
Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Python python 开发语言大数据数据分析数据挖掘
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
数据仓库——维度表一致性墨染丶eye 背诵数据仓库
数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
【Git】常见命令(仅笔记) 好想有猫猫 Git Linux学习笔记 git 笔记 elasticsearch linux c++
文章目录创建/初始化本地仓库添加本地仓库配置项提交文件查看仓库状态回退仓库查看日志分支删除文件暂存工作区代码远程仓库使用`.gitigore`文件让git不追踪一些文件标签创建/初始化本地仓库gitinit添加本地仓库配置项gitconfig-l#以列表形式显示配置项gitconfiguser.name"ljh"#配置user.namegitconfiguser.email"[email protected]
为什么你总是对下属不满意? ZhaoWu1050
【ZhaoWu的听课笔记】大多数公司，都存在两种问题。我创业四年，更是体会深切。这两种问题就是：老板经常不满意下属的表现；下属总是不知道老板想要什么；虽然这两种问题普遍存在，其实解决方法并不复杂。这节课，我们再聊聊第一个问题：为什么老板经常不满意下属表现?其实，这背后也是一条管理常识。管理学家德鲁克先生早就说过：管理者的任务，不是去改变人。*来自《卓有成效的管理者》只是大多数老板和我一样，都是一边
母亲节如何做小红书营销美橙传媒
小红书的一举一动引起了外界的高度关注。通过爆款笔记和流行话题，我们可以看到“干货”类型的内容在小红书中偏向实用的生活经验共享和生活指南非常受欢迎。根据运营社的分析，这种现象是由小红书用户心智和内容社区背后机制共同决定的。首先，小红书将使用“强搜索”逻辑为用户提供特定的“搜索场景”。在“我必须这样生活”中，大量使用了满足小红书站用户喜好和需求的内容。内容社区自制的高质量内容也吸引了寻找营销新途径的品
读书笔记|《遇见孩子，遇见更好的自己》5 抹茶社长
为人父母意味着放弃自己的过去，不要对以往没有实现的心愿耿耿于怀，只有这样，孩子们才能做回自己。985909803.jpg孩子在与父母保持亲密的同时更需要独立，唯有这样，孩子才会成为孩子，父母才会成其为父母。有耐心的人生往往更幸福，给孩子留点余地。认识到养儿育女是对耐心的考验。为失败做好心理准备，教会孩子控制情绪。了解自己的底线，说到底线，有一点很重要，父母之所以发脾气，真正的原因往往在于他们自己，
自然语言处理_tf-idf _feivirus_ 算法机器学习和数学自然语言处理 tf-idf 逆文档频率词频
importpandasaspdimportmath1.数据预处理docA="Thecatsatonmyface"docB="Thedogsatonmybed"wordsA=docA.split("")wordsB=docB.split("")wordsSet=set(wordsA).union(set(wordsB))print(wordsSet){'on','my','face','sat',
基于Python给出的PDF文档转Markdown文档的方法程序媛了了 python pdf 开发语言
注：网上有很多将Markdown文档转为PDF文档的方法，但是却很少有将PDF文档转为Markdown文档的方法。就算有，比如某些网站声称可以将PDF文档转为Markdown文档，尝试过，不太符合自己的要求，而且无法保证文档没有泄露风险。于是本人为了解决这个问题，借助GPT（能使用GPT镜像或者有条件直接使用GPT的，反正能调用GPT接口就行）生成Python代码来完成这个功能。笔记、代码难免存在
语文主题教学学习笔记之87 东哥杂谈
“语文主题教学”学习笔记之八十七（0125）今天继续学习小学语文主题教学的实践样态。板块三：教学中体现“书艺”味道。作为四大名著之一的《水浒传》，堪称我国文学宝库之经典。对从《水浒传》中摘选的单元，教师就要了解其原生态，即评书体特点。这也要求教师要了解一些常用的评书行话术语，然后在教学时适时地加入一些，让学生体味其文本中原有的特色。学生也要尽可能地通过朗读的方式，而不单是分析讲解的方式进行学习。细
Armv8.3 体系结构扩展--原文版代码改变世界ctw ARM-TEE-Android armv8 嵌入式 arm架构安全架构芯片 Trustzone Secureboot
快速链接:.ARMv8/ARMv9架构入门到精通-[目录]付费专栏-付费课程【购买须知】:个人博客笔记导读目录(全部)TheArmv8.3architectureextensionTheArmv8.3architectureextensionisanextensiontoArmv8.2.Itaddsmandatoryandoptionalarchitecturalfeatures.Somefeat
springboot+vue项目实战一-创建SpringBoot简单项目苹果酱0567 面试题汇总与解析 spring boot 后端 java 中间件开发语言
这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
阅读《认知觉醒》读书笔记就看看书
本周阅读了周岭的《认知觉醒开启自我改变的原动力》，启发较多，故做读书笔记一则，留待学习。全书共八章，讲述了大脑、潜意识、元认知、专注力、学习力、行动力、情绪力及成本最低的成长之道。具体描述了大脑、焦虑、耐心、模糊、感性、元认知、自控力、专注力、情绪专注、学习专注、匹配、深度、关联、体系、打卡、反馈、休息、清晰、傻瓜、行动、心智宽带、单一视角、游戏心态、早起、冥想、阅读、写作、运动等相关知识点。大脑
阅读笔记：阅读方法中的逻辑和转念施吉涛
聊聊一些阅读的方法论吧，别人家的读书方法刚开始想写，然后就不知道写什么了，因为作者写的非常的“精致”我有一种乡巴佬进城的感觉，看到精美的摆盘，精致的食材不知道该如何下口也就是《阅读的方法》，我们姑且来试一下强劲的大脑篇，第一节：逻辑通俗的来讲，也就是表达的排列和顺序，再进一步就是因果关系和关联实际上书已经看了大概一遍，但直到打算写一下笔记的时候，才发现作者讲的推理更多的是阅读的对象中呈现出的逻辑也
《转介绍方法论》学习笔记小可乐的妈妈
一、高效转介绍的流程：价值观---执行----方案一）转介绍发生的背景：1、对象：谁向谁转介绍？全员营销，人人参与。①员工的激励政策、客户的转介绍诱因制作客户画像：a信任；支付能力；意愿度；便利度（根据家长具备四个特征的个数分为四类）B性格分类C职业分类D年龄性别②执行：套路，策略，方法，流程2、诱因：为什么要转介绍？认同信任；多方共赢；传递美好；零风险承诺打动人心，超越期待。选择做教育，就是选择
JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式 android java 常用设计模式
博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
解线性方程组 qiuwanchi
package gaodai.matrix; import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class Test { public static void main(String[] args) { Scanner scanner = new Sc
在mysql内部存储代码 annan211 性能 mysql 存储过程触发器
在mysql内部存储代码在mysql内部存储代码，既有优点也有缺点，而且有人倡导有人反对。先看优点： 1 她在服务器内部执行，离数据最近，另外在服务器上执行还可以节省带宽和网络延迟。 2 这是一种代码重用。可以方便的统一业务规则，保证某些行为的一致性，所以也可以提供一定的安全性。 3 可以简化代码的维护和版本更新。 4 可以帮助提升安全，比如提供更细
Android使用Asynchronous Http Client完成登录保存cookie的问题 hotsunshine android
Asynchronous Http Client是android中非常好的异步请求工具除了异步之外还有很多封装比如json的处理，cookie的处理引用 Persistent Cookie Storage with PersistentCookieStore This library also includes a PersistentCookieStore whi
java面试题 Array_06 java 面试
java面试题第一，谈谈final, finally, finalize的区别。 final-修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能
网站加速 oloz 网站加速
前序:本人菜鸟，此文研究总结来源于互联网上的资料，大牛请勿喷！本人虚心学习，多指教. 1、减小网页体积的大小，尽量采用div+css模式，尽量避免复杂的页面结构，能简约就简约。 2、采用Gzip对网页进行压缩； GZIP最早由Jean-loup Gailly和Mark Adler创建，用于UNⅨ系统的文件压缩。我们在Linux中经常会用到后缀为.gz
正确书写单例模式随意而生 java 设计模式单例
　　单例模式算是设计模式中最容易理解，也是最容易手写代码的模式了吧。但是其中的坑却不少，所以也常作为面试题来考。本文主要对几种单例写法的整理，并分析其优缺点。很多都是一些老生常谈的问题，但如果你不知道如何创建一个线程安全的单例，不知道什么是双检锁，那这篇文章可能会帮助到你。　　懒汉式，线程不安全　　当被问到要实现一个单例模式时，很多人的第一反应是写出如下的代码，包括教科书上也是这样
单例模式香水浓 java
懒汉调用getInstance方法时实例化 public class Singleton { private static Singleton instance; private Singleton() {} public static synchronized Singleton getInstance() { if(null == ins
安装Apache问题：系统找不到指定的文件 No installed service named "Apache2" AdyZhang apache http server
安装Apache问题：系统找不到指定的文件 No installed service named "Apache2" 每次到这一步都很小心防它的端口冲突问题，结果，特意留出来的80端口就是不能用，烦。解决方法确保几处： 1、停止IIS启动 2、把端口80改成其它（譬如90，800，，，什么数字都好） 3、防火墙(关掉试试) 在运行处输入 cmd 回车，转到apa
如何在android 文件选择器中选择多个图片或者视频？ aijuans android
我的android app有这样的需求，在进行照片和视频上传的时候，需要一次性的从照片/视频库选择多条进行上传但是android原生态的sdk中，只能一个一个的进行选择和上传。我想知道是否有其他的android上传库可以解决这个问题，提供一个多选的功能，可以使checkbox之类的，一次选择多个处理方法官方的图片选择器(但是不支持所有版本的androi，只支持API Level
mysql中查询生日提醒的日期相关的sql baalwolf mysql
SELECT sysid,user_name,birthday,listid,userhead_50,CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')),CURDATE(), dayofyear( CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')))-dayofyear(
MongoDB索引文件破坏后导致查询错误的问题 BigBird2012 mongodb
问题描述： MongoDB在非正常情况下关闭时，可能会导致索引文件破坏，造成数据在更新时没有反映到索引上。解决方案：使用脚本，重建MongoDB所有表的索引。 var names = db.getCollectionNames(); for( var i in names ){ var name = names[i]; print(name);
Javascript Promise bijian1013 JavaScript Promise
Parse JavaScript SDK现在提供了支持大多数异步方法的兼容jquery的Promises模式，那么这意味着什么呢，读完下文你就了解了。一.认识Promises “Promises”代表着在javascript程序里下一个伟大的范式，但是理解他们为什么如此伟大不是件简
[Zookeeper学习笔记九]Zookeeper源代码分析之Zookeeper构造过程 bit1129 zookeeper
Zookeeper重载了几个构造函数，其中构造者可以提供参数最多，可定制性最多的构造函数是 public ZooKeeper(String connectString, int sessionTimeout, Watcher watcher, long sessionId, byte[] sessionPasswd, boolea
【Java命令三】jstack bit1129 jstack
jstack是用于获得当前运行的Java程序所有的线程的运行情况(thread dump），不同于jmap用于获得memory dump [hadoop@hadoop sbin]$ jstack Usage: jstack [-l] <pid> (to connect to running process) jstack -F
jboss 5.1启停脚本　动静分离部署 ronin47
以前启动jboss，往各种xml配置文件，现只要运行一句脚本即可。start nohup sh /**/run.sh -c servicename -b ip -g clustername -u broatcast jboss.messaging.ServerPeerID=int -Djboss.service.binding.set=p
UI之如何打磨设计能力? brotherlamp UI ui教程 ui自学 ui资料 ui视频
在越来越拥挤的初创企业世界里，视觉设计的重要性往往可以与杀手级用户体验比肩。在许多情况下，尤其对于 Web 初创企业而言，这两者都是不可或缺的。前不久我们在《右脑革命：别学编程了，学艺术吧》中也曾发出过重视设计的呼吁。如何才能提高初创企业的设计能力呢?以下是 9 位创始人的体会。 1.找到自己的方式如果你是设计师，要想提高技能可以去设计博客和展示好设计的网站如D-lists或
三色旗算法 bylijinnan java 算法
import java.util.Arrays; /** 问题：假设有一条绳子，上面有红、白、蓝三种颜色的旗子，起初绳子上的旗子颜色并没有顺序，您希望将之分类，并排列为蓝、白、红的顺序，要如何移动次数才会最少，注意您只能在绳子上进行这个动作，而且一次只能调换两个旗子。网上的解法大多类似：在一条绳子上移动，在程式中也就意味只能使用一个阵列，而不使用其它的阵列来
警告:No configuration found for the specified action: \'s chiangfai configuration
1.index.jsp页面form标签未指定namespace属性。  <%@taglib prefix="s" uri="/struts-tags"%> ... <s:form action="submit" method="post"&g
redis -- hash_max_zipmap_entries设置过大有问题 chenchao051 redis hash
使用redis时为了使用hash追求更高的内存使用率，我们一般都用hash结构，并且有时候会把hash_max_zipmap_entries这个值设置的很大，很多资料也推荐设置到1000，默认设置为了512，但是这里有个坑 #define ZIPMAP_BIGLEN 254 #define ZIPMAP_END 255 /* Return th
select into outfile access deny问题 daizj mysql txt 导出数据到文件
本文转自：http://hatemysql.com/2010/06/29/select-into-outfile-access-deny%E9%97%AE%E9%A2%98/ 为应用建立了rnd的帐号，专门为他们查询线上数据库用的，当然，只有他们上了生产网络以后才能连上数据库，安全方面我们还是很注意的，呵呵。授权的语句如下： grant select on armory.* to rn
phpexcel导出excel表简单入门示例 dcj3sjt126com PHP Excel phpexcel
<?php error_reporting(E_ALL); ini_set('display_errors', TRUE); ini_set('display_startup_errors', TRUE); if (PHP_SAPI == 'cli') die('This example should only be run from a Web Brows
美国电影超短200句 dcj3sjt126com 电影
1. I see．我明白了。2. I quit! 我不干了!3. Let go! 放手!4. Me too．我也是。5. My god! 天哪!6. No way! 不行!7. Come on．来吧(赶快)8. Hold on．等一等。9. I agree。我同意。10. Not bad．还不错。11. Not yet．还没。12. See you．再见。13. Shut up!
Java访问远程服务 dyy_gusi httpclient webservice get post
随着webService的崛起，我们开始中会越来越多的使用到访问远程webService服务。当然对于不同的webService框架一般都有自己的client包供使用，但是如果使用webService框架自己的client包，那么必然需要在自己的代码中引入它的包，如果同时调运了多个不同框架的webService，那么就需要同时引入多个不同的clien
Maven的settings.xml配置 geeksun settings.xml
settings.xml是Maven的配置文件，下面解释一下其中的配置含义： settings.xml存在于两个地方： 1.安装的地方：$M2_HOME/conf/settings.xml 2.用户的目录：${user.home}/.m2/settings.xml 前者又被叫做全局配置，后者被称为用户配置。如果两者都存在，它们的内容将被合并，并且用户范围的settings.xml优先。
ubuntu的init与系统服务设置 hongtoushizi ubuntu
转载自： http://iysm.net/?p=178 init Init是位于/sbin/init的一个程序，它是在linux下，在系统启动过程中，初始化所有的设备驱动程序和数据结构等之后，由内核启动的一个用户级程序，并由此init程序进而完成系统的启动过程。 ubuntu与传统的linux略有不同，使用upstart完成系统的启动，但表面上仍维持init程序的形式。运行
跟我学Nginx+Lua开发目录贴 jinnianshilongnian nginx lua
使用Nginx+Lua开发近一年的时间，学习和实践了一些Nginx+Lua开发的架构，为了让更多人使用Nginx+Lua架构开发，利用春节期间总结了一份基本的学习教程，希望对大家有用。也欢迎谈探讨学习一些经验。目录第一章安装Nginx+Lua开发环境第二章 Nginx+Lua开发入门第三章 Redis/SSDB+Twemproxy安装与使用第四章 L
php位运算符注意事项 home198979 位运算 PHP &
$a = $b = $c = 0; $a & $b = 1; $b | $c = 1 问a,b,c最终为多少? 当看到这题时，我犯了一个低级错误，误以为位运算符会改变变量的值。所以得出结果是1 1 0 但是位运算符是不会改变变量的值的，例如： $a=1;$b=2; $a&$b; 这样a,b的值不会有任何改变
Linux shell数组建立和使用技巧 pda158 linux
1.数组定义　　[chengmo@centos5 ~]$ a=(1 2 3 4 5) 　　[chengmo@centos5 ~]$ echo $a 　　1 　　一对括号表示是数组，数组元素用“空格”符号分割开。　　 2.数组读取与赋值　　得到长度：　　[chengmo@centos5 ~]$ echo ${#a[@]} 　　5 　　用${#数组名[@或
hotspot源码(JDK7) ol_beta java HotSpot jvm
源码结构图，方便理解： ├─agent Serviceab
Oracle基本事务和ForAll执行批量DML练习 vipbooks oracle sql
基本事务的使用：从账户一的余额中转100到账户二的余额中去，如果账户二不存在或账户一中的余额不足100则整笔交易回滚 select * from account; -- 创建一张账户表 create table account( -- 账户ID id number(3) not null, -- 账户名称 nam