一、介绍

知识点

  • 使用 Python 从网络上爬取信息的基本方法
  • 处理语料“洗数据”的基本方法
  • 词袋模型搭建方法
  • 简单 RNN 的搭建方法
  • 简单 LSTM 的搭建方法

二、从网络中抓取并处理数据

引入相关包

下载数据 网盘链接：https://pan.baidu.com/s/1Jg5NPxc9L-M8Tdgh70Tvig 提取码：dpqq

# 导入程序所需要的程序包

#PyTorch用的包

import torch

import torch.nn as nn

import torch.optim

from torch.autograd import Variable

# 自然语言处理相关的包

import re #正则表达式的包

import jieba #结巴分词包

from collections import Counter #搜集器，可以让统计词频更简单

#绘图、计算用的程序包

import matplotlib.pyplot as plt

import numpy as np

%matplotlib inline

数据预处理(洗数据)

提供了爬取好的评论文本在 data/good.txt 以及 data/bad.txt 中。

# 将文本中的标点符号过滤掉

def filter_punc(sentence):

    sentence = re.sub("[\s+\.\!\/_,$%^*(+\"\'“”《》?“]+|[+——！，。？、~@#￥%……&*（）：]+", "", sentence)

    return(sentence)

在下面的函数代码中，首先会循环文本文件中的每行评论，过滤标点符号，分词。

将分词好的评论分别放置在 pos_sentences 与 neg_sentences 中。

# 扫描所有的文本，分词、建立词典，分出正向还是负向的评论，is_filter可以过滤是否筛选掉标点符号

def Prepare_data(good_file, bad_file, is_filter = True):

    all_words = [] #存储所有的单词

    pos_sentences = [] #存储正向的评论

    neg_sentences = [] #存储负向的评论

    with open(good_file, 'r') as fr:

        for idx, line in enumerate(fr):

            if is_filter:

                #过滤标点符号

                line = filter_punc(line)

            #分词

            words = jieba.lcut(line)

            if len(words) > 0:

                all_words += words

                pos_sentences.append(words)

    print('{0} 包含 {1} 行, {2} 个词.'.format(good_file, idx+1, len(all_words)))

    count = len(all_words)

    with open(bad_file, 'r') as fr:

        for idx, line in enumerate(fr):

            if is_filter:

                line = filter_punc(line)

            words = jieba.lcut(line)

            if len(words) > 0:

                all_words += words

                neg_sentences.append(words)

    print('{0} 包含 {1} 行, {2} 个词.'.format(bad_file, idx+1, len(all_words)-count))

    #建立词典，diction的每一项为{w:[id, 单词出现次数]}

    diction = {}

    cnt = Counter(all_words)

    for word, freq in cnt.items():

        diction[word] = [len(diction), freq]

    print('字典大小：{}'.format(len(diction)))

    return(pos_sentences, neg_sentences, diction)

这两个函数一个是用“词”来查“索引号”，一个是用“索引号”来查“词”。

#根据单词返还单词的编码

def word2index(word, diction):

    if word in diction:

        value = diction[word][0]

    else:

        value = -1

    return(value)

#根据编码获得单词

def index2word(index, diction):

    for w,v in diction.items():

        if v[0] == index:

            return(w)

    return(None)

下面将读取包含商品评论信息的两个文本文件。

good_file = 'data/good.txt'

bad_file  = 'data/bad.txt'

pos_sentences, neg_sentences, diction = Prepare_data(good_file, bad_file, True)

st = sorted([(v[1], w) for w, v in diction.items()])

print(st)

三、基于词袋模型的简单文本分类器

词带模型就是将一句话中的所有单词都放进一个袋子里（单词表），而忽略掉语法、语义，甚至单词之间的顺序这些所有的信息。最终只关心每一个单词的数量，然后根据这个数量来建立对句子进行表征的向量。

训练数据准备

输入一个句子和相应的词典，得到这个句子的向量化表示。

# 输入一个句子和相应的词典，得到这个句子的向量化表示。

def sentence2vec(sentence, dictionary):

    vector = np.zeros(len(dictionary))

    for l in sentence:

        vector[l] += 1

    return(1.0 * vector / len(sentence))

以句子为单位，将所有的积极情感的评论文本，全部转化为句子向量，并保存到数据集 dataset 中。

# 遍历所有句子，将每一个词映射成编码

dataset = [] #数据集

labels = [] #标签

sentences = [] #原始句子，调试用

# 处理正向评论

for sentence in pos_sentences:

    new_sentence = []

    for l in sentence:

        if l in diction:

            new_sentence.append(word2index(l, diction))

    dataset.append(sentence2vec(new_sentence, diction))

    labels.append(0) #正标签为0

    sentences.append(sentence)

对于消极情绪的评论如法炮制

# 处理负向评论

for sentence in neg_sentences:

    new_sentence = []

    for l in sentence:

        if l in diction:

            new_sentence.append(word2index(l, diction))

    dataset.append(sentence2vec(new_sentence, diction))

    labels.append(1) #负标签为1

    sentences.append(sentence)

下面进行数据集的切分。

#打乱所有的数据顺序，形成数据集

# indices为所有数据下标的一个全排列

indices = np.random.permutation(len(dataset))

#重新根据打乱的下标生成数据集dataset，标签集labels，以及对应的原始句子sentences

dataset = [dataset[i] for i in indices]

labels = [labels[i] for i in indices]

sentences = [sentences[i] for i in indices]

#对整个数据集进行划分，分为：训练集、校准集和测试集，其中校准和测试集合的长度都是整个数据集的10分之一

test_size = len(dataset) // 10

train_data = dataset[2 * test_size :]

train_label = labels[2 * test_size :]

valid_data = dataset[: test_size]

valid_label = labels[: test_size]

test_data = dataset[test_size : 2 * test_size]

test_label = labels[test_size : 2 * test_size]

模型定义

建立多层前馈网络

# 一个简单的前馈神经网络，三层，第一层线性层，加一个非线性ReLU，第二层线性层，中间有10个隐含层神经元

# 输入维度为词典的大小：每一段评论的词袋模型

model = nn.Sequential(

    nn.Linear(len(diction), 10),

    nn.ReLU(),

    nn.Linear(10, 2),

    nn.LogSoftmax(dim=1),

)

编写的是计算预测错误率的函数。

def rightness(predictions, labels):

    """计算预测错误率的函数，其中predictions是模型给出的一组预测结果，

       batch_size行num_classes列的矩阵，labels是数据之中的正确答案"""

    # 对于任意一行（一个样本）的输出值的第1个维度，求最大，得到每一行的最大元素的下标

    pred = torch.max(predictions.data, 1)[1]

    #将下标与labels中包含的类别进行比较，并累计得到比较正确的数量

    rights = pred.eq(labels.data.view_as(pred)).sum()

    #返回正确的数量和这一次一共比较了多少元素

    return rights, len(labels)

训练模型

建立好神经网络之后，就可以进行训练了。

# 损失函数为交叉熵

cost = torch.nn.NLLLoss()

# 优化算法为Adam，可以自动调节学习率

optimizer = torch.optim.Adam(model.parameters(), lr = 0.01)


# 记录列表，记录训练时的各种数据，以用于绘图

records = []

# loss 列表，用于记录训练中的 loss

losses = []

def trainModel(data, label):

    # 需要将输入的数据进行适当的变形，主要是要多出一个batch_size的维度，也即第一个为1的维度

    # 这样做是为了适应 PyTorch 函数的特殊用法，具体可以参考 PyTorch 官方文档

    x = Variable(torch.FloatTensor(data).view(1,-1))

    # x的尺寸：batch_size=1, len_dictionary

    # 标签也要加一层外衣以变成1*1的张量

    y = Variable(torch.LongTensor(np.array([label])))

    # y的尺寸：batch_size=1, 1

    # 清空梯度

    optimizer.zero_grad()

    # 模型预测

    predict = model(x)

    # 计算损失函数

    loss = cost(predict, y)

    # 将损失函数数值加入到列表中

    losses.append(loss.data.numpy())

    # 开始进行梯度反传

    loss.backward()

    # 开始对参数进行一步优化

    optimizer.step()

验证模型的函数

def evaluateModel(data, label):

    x = Variable(torch.FloatTensor(data).view(1, -1))

    y = Variable(torch.LongTensor(np.array([label])))

    # 模型预测

    predict = model(x)

    # 调用rightness函数计算准确度

    right = rightness(predict, y)

    # 计算loss

    loss = cost(predict, y)

    return predict, right, loss

训练循环部分

#循环10个Epoch

for epoch in range(10):

    for i, data in enumerate(zip(train_data, train_label)):

        x, y = data

        # 调用上面编写的训练函数

        # x 即句子向量，y 即标签（0 or 1）

        trainModel(x, y)

        # 每隔3000步，跑一下校验数据集的数据，输出临时结果

        if i % 3000 == 0:

            val_losses = []

            rights = []

            # 在所有校验数据集上实验

            for j, val in enumerate(zip(valid_data, valid_label)):

                x, y = val

                # 调用模型测试函数

                predict, right, loss = evaluateModel(x, y)

                rights.append(right)

                val_losses.append(loss.data.numpy())

            # 将校验集合上面的平均准确度计算出来

            right_ratio = 1.0 * np.sum([i[0] for i in rights]) / np.sum([i[1] for i in rights])

            print('第{}轮，训练损失：{:.2f}, 校验损失：{:.2f}, 校验准确率: {:.2f}'.format(epoch, np.mean(losses),np.mean(val_losses), right_ratio))

            records.append([np.mean(losses), np.mean(val_losses), right_ratio])

绘制图像观察模型训练情况

损失函数和准确度的曲线画出来

# 绘制误差曲线

a = [i[0] for i in records]

b = [i[1] for i in records]

c = [i[2] for i in records]

plt.plot(a, label = 'Train Loss')

plt.plot(b, label = 'Valid Loss')

plt.plot(c, label = 'Valid Accuracy')

plt.xlabel('Steps')

plt.ylabel('Loss & Accuracy')

plt.legend()

在整个测试集上运行，记录预测结果，并计算总的正确率。

vals = [] #记录准确率所用列表

#对测试数据集进行循环

for data, target in zip(test_data, test_label):

    data, target = Variable(torch.FloatTensor(data).view(1,-1)), Variable(torch.LongTensor(np.array([target])))

    output = model(data) #将特征数据喂入网络，得到分类的输出

    val = rightness(output, target) #获得正确样本数以及总样本数

    vals.append(val) #记录结果

#计算准确率

rights = (sum([tup[0] for tup in vals]), sum([tup[1] for tup in vals]))

right_rate = 1.0 * rights[0].data.numpy() / rights[1]

print(right_rate)

四、基于 RNN 的简单文本分类器

了解 RNN 模型如何实现，以及考察它们在测试数据集上的分类准确度。

普通RNN模型

正如词袋模型那样，首先加载并预处理数据。

与词袋模型不同，在这次 RNN 的实验中，不去除评论语料中的标点符号。

# 需要重新数据预处理，主要是要加上标点符号，它对于RNN起到重要作用

# 数据来源文件

good_file = 'data/good.txt'

bad_file  = 'data/bad.txt'

pos_sentences, neg_sentences, diction = Prepare_data(good_file, bad_file, False)


dataset = []

labels = []

sentences = []

# 正例集合

for sentence in pos_sentences:

    new_sentence = []

    for l in sentence:

        if l in diction:

            # 注意将每个词编码

            new_sentence.append(word2index(l, diction))

    #每一个句子都是一个不等长的整数序列

    dataset.append(new_sentence)

    labels.append(0)

    sentences.append(sentence)

# 反例集合

for sentence in neg_sentences:

    new_sentence = []

    for l in sentence:

        if l in diction:

            new_sentence.append(word2index(l, diction))

    dataset.append(new_sentence)

    labels.append(1)

    sentences.append(sentence)

# 重新对数据洗牌，构造数据集合

indices = np.random.permutation(len(dataset))

dataset = [dataset[i] for i in indices]

labels = [labels[i] for i in indices]

sentences = [sentences[i] for i in indices]

test_size = len(dataset) // 10

# 训练集

train_data = dataset[2 * test_size :]

train_label = labels[2 * test_size :]

# 校验集

valid_data = dataset[: test_size]

valid_label = labels[: test_size]

# 测试集

test_data = dataset[test_size : 2 * test_size]

test_label = labels[test_size : 2 * test_size]

采用手动编写模型的方式，以熟悉 RNN 的结构与工作流程。本次要搭建的 RNN 模型结构如下：

# 一个手动实现的RNN模型

class RNN(nn.Module):

    def __init__(self, input_size, hidden_size, output_size):

        super(RNN, self).__init__()

        self.hidden_size = hidden_size

        # 一个embedding层

        self.embed = nn.Embedding(input_size, hidden_size)

        # 隐含层内部的相互链接

        self.i2h = nn.Linear(2 * hidden_size, hidden_size)

        # 隐含层到输出层的链接

        self.i2o = nn.Linear(hidden_size, output_size)

        self.softmax = nn.LogSoftmax(dim=1)

    def forward(self, input, hidden):

        # 先进行embedding层的计算，它可以把一个数或者数列，映射成一个向量或一组向量

        # input尺寸：seq_length, 1

        x = self.embed(input)

        # x尺寸：hidden_size

        # 将输入和隐含层的输出（hidden）耦合在一起构成了后续的输入

        combined = torch.cat((x.view(1, -1), hidden), 1)

        # combined尺寸：2*hidden_size

        #

        # 从输入到隐含层的计算

        hidden = self.i2h(combined)

        # combined尺寸：hidden_size

        # 从隐含层到输出层的运算

        output = self.i2o(hidden)

        # output尺寸：output_size

        # softmax函数

        output = self.softmax(output)

        return output, hidden

    def initHidden(self):

        # 对隐含单元的初始化

        # 注意尺寸是：batch_size, hidden_size

        return Variable(torch.zeros(1, self.hidden_size))

训练这个 RNN 网络。

# 开始训练这个RNN，10个隐含层单元

rnn = RNN(len(diction), 10, 2)

# 交叉熵评价函数

cost = torch.nn.NLLLoss()

# Adam优化器

optimizer = torch.optim.Adam(rnn.parameters(), lr = 0.001)

records = []

# 学习周期10次

losses = []

for epoch in range(10):

    for i, data in enumerate(zip(train_data, train_label)):

        x, y = data

        x = Variable(torch.LongTensor(x))

        #x尺寸：seq_length（序列的长度）

        y = Variable(torch.LongTensor([y]))

        #x尺寸：batch_size = 1,1

        optimizer.zero_grad()

        #初始化隐含层单元全为0

        hidden = rnn.initHidden()

        # hidden尺寸：batch_size = 1, hidden_size

        #手动实现RNN的时间步循环，x的长度就是总的循环时间步，因为要把x中的输入句子全部读取完毕

        for s in range(x.size()[0]):

            output, hidden = rnn(x[s], hidden)

        #校验函数

        loss = cost(output, y)

        losses.append(loss.data.numpy())

        loss.backward()

        # 开始优化

        optimizer.step()

        if i % 3000 == 0:

            # 每间隔3000步来一次校验集上面的计算

            val_losses = []

            rights = []

            for j, val in enumerate(zip(valid_data, valid_label)):

                x, y = val

                x = Variable(torch.LongTensor(x))

                y = Variable(torch.LongTensor(np.array([y])))

                hidden = rnn.initHidden()

                for s in range(x.size()[0]):

                    output, hidden = rnn(x[s], hidden)

                right = rightness(output, y)

                rights.append(right)

                loss = cost(output, y)

                val_losses.append(loss.data.numpy())

            # 计算准确度

            right_ratio = 1.0 * np.sum([i[0] for i in rights]) / np.sum([i[1] for i in rights])

            print('第{}轮，训练损失：{:.2f}, 测试损失：{:.2f}, 测试准确率: {:.2f}'.format(epoch, np.mean(losses),np.mean(val_losses), right_ratio))

            records.append([np.mean(losses), np.mean(val_losses), right_ratio])

绘制 RNN 模型的误差曲线

# 绘制误差曲线

a = [i[0] for i in records]

b = [i[1] for i in records]

c = [i[2] for i in records]

plt.plot(a, label = 'Train Loss')

plt.plot(b, label = 'Valid Loss')

plt.plot(c, label = 'Valid Accuracy')

plt.xlabel('Steps')

plt.ylabel('Loss & Accuracy')

plt.legend()

在测试集上运行，并计算准确率。

vals = [] #记录准确率所用列表

rights = list(rights)

#对测试数据集进行循环

for j, test in enumerate(zip(test_data, test_label)):

    x, y = test

    x = Variable(torch.LongTensor(x))

    y = Variable(torch.LongTensor(np.array([y])))

    hidden = rnn.initHidden()

    for s in range(x.size()[0]):

        output, hidden = rnn(x[s], hidden)

    right = rightness(output, y)

    rights.append(right)

    val = rightness(output, y) #获得正确样本数以及总样本数

    vals.append(val) #记录结果

#计算准确率

rights = (sum([tup[0] for tup in vals]), sum([tup[1] for tup in vals]))

right_rate = 1.0 * rights[0].data.numpy() / rights[1]

right_rate

将模型保存下来。

# 保存、加载模型（为讲解用）

torch.save(rnn, 'rnn.mdl')

rnn = torch.load('rnn.mdl')

五、基于 LSTM 的简单文本分类器

普通 RNN 的效果并不好，可以尝试利用改进型的 RNN，即 LSTM。

LSTM 与 RNN 最大的区别就是在于每个神经元中多增加了3个控制门：遗忘门、输入门和输出门。

另外，在每个隐含层神经元中，LSTM 多了一个 cell 的状态，起到了记忆的作用。

这就使得 LSTM 可以记忆更长时间的 Pattern。

class LSTMNetwork(nn.Module):

    def __init__(self, input_size, hidden_size, n_layers=1):

        super(LSTMNetwork, self).__init__()

        self.n_layers = n_layers

        self.hidden_size = hidden_size

        # LSTM的构造如下：一个embedding层，将输入的任意一个单词映射为一个向量

        # 一个LSTM隐含层，共有hidden_size个LSTM神经元

        # 一个全链接层，外接一个softmax输出

        self.embedding = nn.Embedding(input_size, hidden_size)

        self.lstm = nn.LSTM(hidden_size, hidden_size, n_layers)

        self.fc = nn.Linear(hidden_size, 2)

        self.logsoftmax = nn.LogSoftmax(dim=1)

    def forward(self, input, hidden=None):

        #input尺寸: seq_length

        #词向量嵌入

        embedded = self.embedding(input)

        #embedded尺寸: seq_length, hidden_size

        #PyTorch设计的LSTM层有一个特别别扭的地方是，输入张量的第一个维度需要是时间步，

        #第二个维度才是batch_size，所以需要对embedded变形

        embedded = embedded.view(input.data.size()[0], 1, self.hidden_size)

        #embedded尺寸: seq_length, batch_size = 1, hidden_size

        #调用PyTorch自带的LSTM层函数，注意有两个输入，一个是输入层的输入，另一个是隐含层自身的输入

        # 输出output是所有步的隐含神经元的输出结果，hidden是隐含层在最后一个时间步的状态。

        # 注意hidden是一个tuple，包含了最后时间步的隐含层神经元的输出，以及每一个隐含层神经元的cell的状态

        output, hidden = self.lstm(embedded, hidden)

        #output尺寸: seq_length, batch_size = 1, hidden_size

        #hidden尺寸: 二元组(n_layer = 1 * batch_size = 1 * hidden_size, n_layer = 1 * batch_size = 1 * hidden_size)

        #我们要把最后一个时间步的隐含神经元输出结果拿出来，送给全连接层

        output = output[-1,...]

        #output尺寸: batch_size = 1, hidden_size

        #全链接层

        out = self.fc(output)

        #out尺寸: batch_size = 1, output_size

        # softmax

        out = self.logsoftmax(out)

        return out

    def initHidden(self):

        # 对隐单元的初始化

        # 对隐单元输出的初始化，全0.

        # 注意hidden和cell的维度都是layers,batch_size,hidden_size

        hidden = Variable(torch.zeros(self.n_layers, 1, self.hidden_size))

        # 对隐单元内部的状态cell的初始化，全0

        cell = Variable(torch.zeros(self.n_layers, 1, self.hidden_size))

        return (hidden, cell)

训练 LSTM 模型。

# 开始训练LSTM网络

# 构造一个LSTM网络的实例

lstm = LSTMNetwork(len(diction), 10, 2)

#定义损失函数

cost = torch.nn.NLLLoss()

#定义优化器

optimizer = torch.optim.Adam(lstm.parameters(), lr = 0.001)

records = []

# 开始训练，一共15个epoch

losses = []

for epoch in range(15):

    for i, data in enumerate(zip(train_data, train_label)):

        x, y = data

        x = Variable(torch.LongTensor(x))

        #x尺寸：seq_length，序列的长度

        y = Variable(torch.LongTensor([y]))

        #y尺寸：batch_size = 1, 1

        optimizer.zero_grad()

        #初始化LSTM隐含层单元的状态

        hidden = lstm.initHidden()

        #hidden: 二元组(n_layer = 1 * batch_size = 1 * hidden_size, n_layer = 1 * batch_size = 1 * hidden_size)

        #让LSTM开始做运算，注意，不需要手工编写对时间步的循环，而是直接交给PyTorch的LSTM层。

        #它自动会根据数据的维度计算若干时间步

        output = lstm(x, hidden)

        #output尺寸: batch_size = 1, output_size

        #损失函数

        loss = cost(output, y)

        losses.append(loss.data.numpy())

        #反向传播

        loss.backward()

        optimizer.step()

        #每隔3000步，跑一次校验集，并打印结果

        if i % 3000 == 0:

            val_losses = []

            rights = []

            for j, val in enumerate(zip(valid_data, valid_label)):

                x, y = val

                x = Variable(torch.LongTensor(x))

                y = Variable(torch.LongTensor(np.array([y])))

                hidden = lstm.initHidden()

                output = lstm(x, hidden)

                #计算校验数据集上的分类准确度

                right = rightness(output, y)

                rights.append(right)

                loss = cost(output, y)

                val_losses.append(loss.data.numpy())

            right_ratio = 1.0 * np.sum([i[0] for i in rights]) / np.sum([i[1] for i in rights])

            print('第{}轮，训练损失：{:.2f}, 测试损失：{:.2f}, 测试准确率: {:.2f}'.format(epoch, np.mean(losses),np.mean(val_losses), right_ratio))

            records.append([np.mean(losses), np.mean(val_losses), right_ratio])

在测试集上计算总的正确率。

vals = [] #记录准确率所用列表

rights = list(rights)

#对测试数据集进行循环

for j, test in enumerate(zip(test_data, test_label)):

    x, y = test

    x = Variable(torch.LongTensor(x))

    y = Variable(torch.LongTensor(np.array([y])))

    hidden = lstm.initHidden()

    output = lstm(x, hidden)

    right = rightness(output, y)

    rights.append(right)

    val = rightness(output, y) #获得正确样本数以及总样本数

    vals.append(val) #记录结果

#计算准确率

rights = (sum([tup[0] for tup in vals]), sum([tup[1] for tup in vals]))

right_rate = 1.0 * rights[0].data.numpy() / rights[1]

right_rate

保存模型。

#保存、加载模型（为讲解用）

torch.save(lstm, 'lstm.mdl')

lstm = torch.load('lstm.mdl')

六、总结

尝试了两种 RNN 网络，一种是普通的 RNN，另一种是 LSTM。展示了它们在处理同样的文本分类问题上的用法。

PyTorch基础——使用神经网络识别文字中的情感信息的更多相关文章

  1. Zybo智能小车识别图像中的文字

    智能小车识别图像中的文字 [TOC] 运行平台 这次的内容是基于Xilinx公司的Zybo开发板以及其配套的Zrobot套件开发 Zybo上面的sd卡搭载了Ubuntu12.04LTS的linux版本 ...

  2. 利用百度文字识别API识别图像中的文字

      本文将会介绍如何使用百度AI开放平台中的文字识别服务来识别图片中的文字.百度AI开放平台的访问网址为:http://ai.baidu.com/ ,为了能够使用该平台提供的AI服务,你需要事先注册一 ...

  3. PyTorch基础——机器翻译的神经网络实现

    一.介绍 内容 "基于神经网络的机器翻译"出现了"编码器+解码器+注意力"的构架,让机器翻译的准确度达到了一个新的高度.所以本次主题就是"基于深度神经 ...

  4. pytorch基础学习（二）

    在神经网络训练时,还涉及到一些tricks,如网络权重的初始化方法,优化器种类(权重更新),图片预处理等,继续填坑. 1. 神经网络初始化(Network Initialization ) 1.1 初 ...

  5. [人工智能]Pytorch基础

    PyTorch基础 摘抄自<深度学习之Pytorch>. Tensor(张量) PyTorch里面处理的最基本的操作对象就是Tensor,表示的是一个多维矩阵,比如零维矩阵就是一个点,一维 ...

  6. 【新生学习】第一周：深度学习及pytorch基础

    DEADLINE: 2020-07-25 22:00 写在最前面: 本课程的主要思路还是要求大家大量练习 pytorch 代码,在写代码的过程中掌握深度学习的各类算法,希望大家能够坚持练习,相信经度过 ...

  7. Pytorch_第六篇_深度学习 (DeepLearning) 基础 [2]---神经网络常用的损失函数

    深度学习 (DeepLearning) 基础 [2]---神经网络常用的损失函数 Introduce 在上一篇"深度学习 (DeepLearning) 基础 [1]---监督学习和无监督学习 ...

  8. PowerShell_零基础自学课程_6_PS中获取帮助信息详解、管道、格式化输

    前些文章陆续的说了一些关于这些主题,但是讨论的都不够深入,今天我们深入的了解一下获取帮助信息.管道以及格式化输出的内容. 一.获取帮助信息 在PS中获取帮助信息,最常用的有: -? .get-comm ...

  9. 使用TensorFlow的卷积神经网络识别自己的单个手写数字，填坑总结

    折腾了几天,爬了大大小小若干的坑,特记录如下.代码在最后面. 环境: Python3.6.4 + TensorFlow 1.5.1 + Win7 64位 + I5 3570 CPU 方法: 先用MNI ...

随机推荐

  1. 为什么 execute(`echo 中文`) 输出中文源码？

    为什么 execute(echo 中文) 输出中文源码? import win.ui; /*DSG{{*/ var winform = win.form(text="管道演示";r ...

  2. GIT 操作文档

    https://git-scm.com/book/en/v2 安装git地址:https://git-scm.com/downloads 一.初始化设置 1.设置你用户名称与邮件地址(每一个 Git ...

  3. 日志处理中一些shell命令技巧

    日志处理中一些shell命令技巧 阴差阳错的做的日志分析,前途未卜的这段日子,唯一还有点意思的可能就是手动的处理大量日志.总结一下. 日志文件的输入是动则几个G的文本.从N个这样的文件中得到一个列表, ...

  4. CTF - bugku-分析

    1.flag被盗 下载链接是.pcang文件 用wireshark打开 像这种流量分析题目,就要用Wireshark自带的搜索功能找尝试查找一些关键词(比如key.flag.shell.pass等) ...

  5. 使用Dom4j生成xml文件（utf-8编码）

    xml文件内容: <?xml version="1.0" encoding="UTF-8"?> <result> <code> ...

  6. 最短路问题--P4779 单源最短路（标准版）Dijkstra堆优化

    题目背景 2018 年7月 19 日,某位同学在 NOI Day 1 T1 归程 一题里非常熟练地使用了一个广为人知的算法求最短路. 最终,他因此没能与理想的大学达成契约. 小 F 衷心祝愿大家不再重 ...

  7. MySQL高负载优化

    MySQL配置文件优化 [client] port = #客户端端口号为3306 socket = /data//mysql.sock # default-character-set = utf8 # ...

  8. 步进电机加减速S曲线算法

    一.Sigmoid 函数 1.1 Sigmoid函数原型 1.2 sigmoid函数波形: 由图形可看出在-10时已经接近于0,一般取值区间在[-5,5]. 1.3 sigmoid函数的导数 转载CS ...

  9. vue表单选项框

    选项框选的内容在下面显示 <!DOCTYPE html> <html lang="en"> <head> <meta charset=&q ...

  10. 汪慧和201771010123《面向对象程序设计JAVA》第四周实验总结

    第一部分:理论知识学习部分 1.类 类(class)是具有相同属性和行为的一组对象的集合,是构造程序的基本单元,是构造对象的模板或蓝图. 2.对象 对象:即数据,对象有三个特性——1.行为 2.状态 ...