libtorch-char-rnn-shakespeare

已于 2024-07-04 10:46:59 修改
阅读量1.3k 收藏 30
点赞数
文章标签： rnn 人工智能 深度学习 分类 opencv 机器学习 神经网络
于 2024-07-04 08:31:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/barcaFC/article/details/140168432
版权

libtorch-char-rnn-shakespeare

libtorch-UNET Carvana车辆轮廓分割
libtorch-VGG cifar10分类
libtorch-FCN CamVid语义分割
libtorch-RDN DIV2K超分重建
libtorch-char-rnn-classification libtorch官网系列教程
libtorch-char-rnn-generation libtorch官网系列教程
libtorch-char-rnn-shakespeare libtorch官网系列教程
libtorch-minst libtorch官网系列教程
————————————————

                        版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

原文链接：https://blog.csdn.net/barcaFC/article/details/140116269

文章目录

前言

延续pytorch-rnn官网教程，本文为libtorch教程上的文章内容生成，使用的是莎士比亚文章内容进行学习和生成，可以自由修改成看图写话或者小短文的生成。
今年我国在内容生成上的专利申请数全球第一。
内容生成可以生成数据、文字、图片、视频、音乐等等。然而，再重复一次，解决问题不是要全球领先，而是根据实际问题选用合适的模型进行改动。

libtorch C++ libtorch-char-rnn-shakespeare
从数据集准备、训练、推理 全部由libtorch c++完成
运行环境:
操作系统:windows 64位
opencv3.4.1
libtorch 任意版本 64位
visual stdio 2017 64位编译
关联参考:
https://pytorch.org/tutorials/intermediate/char_rnn_generation_tutorial.html
https://github.com/spro/practical-pytorch/tree/master/char-rnn-generation
RNN_KERNEL_VERSION 变为2.0版本,使用encoder-decoder结构、WordEmbedding、rnn-GRU
因为生成对话需要较长距离的上下文内容
系列中data.hpp文件跟随官网改变成helpers.hpp
read_file函数读取原始文件内容由前两版ReadContentFromFiles函数修改而来
————————————————

一、rnn-shakespeare是什么？

和基于字符级生成不同，本文使用WordEmbedding，对词进行了编码使得能够词生成，而且结构上具有了后续seq2seq的核心模型encoder-decoder。而模型演示的encoder-decoder也很简单但实现的功能确是很强大的。
无论是RDN进行图片重建或者是RNN内容生成，均具有前后关联(跳跃链接、隐藏层)以及encoder-decoder结构。

二、使用步骤

1.设置参数

int main(int argc, char **argv)
{
	if (torch::cuda::is_available())
	{
		printf("torch::cuda::is_available\n");
		device_type = torch::kCUDA;
	}
	else
	{
		printf("cpu is_available\n");
		device_type = torch::kCPU;
	}
	torch::Device device(device_type);

#if _TRAIN_STAGE_		//训练
	srand((unsigned)time(NULL));

	read_file(L"..\\data\\shakespeare.txt");

	RNN decoder(n_characters, hidden_size, n_characters, n_layers);

	auto decoder_optimizer = torch::optim::Adam(decoder.parameters(), torch::optim::AdamOptions(learning_rate));
	auto criterion = torch::nn::CrossEntropyLoss();

	printf("Training for %d epochs...", n_epochs);

	//float loss_avg = 0;

	for (int epoch = 0; epoch < n_epochs; epoch++)
	{
		std::tuple<torch::Tensor, torch::Tensor> retRandomSet = random_training_set(chunk_len);
		torch::Tensor inp = std::get<0>(retRandomSet);
		torch::Tensor target = std::get<1>(retRandomSet);
		//printf("random_training_set : %d %d\n", inp.sizes(), target.sizes());
		//cout << endl << "inp.sizes()::" << inp.sizes() << "target.sizes()::" << target.sizes() << endl;

		torch::Tensor loss = train(decoder, device, inp, target, decoder_optimizer, criterion);
		//printf("train : %.4f\n", loss.item().toFloat());
		//loss_avg += (loss.item().toFloat() / chunk_len);
		//Print epoch number, loss, name and guess
		if (0 == (epoch % print_every))
		{
			printf("(%d %d%%) loss: %.4f\n", epoch, epoch / n_epochs, (loss.item().toFloat() / chunk_len));
			//loss_avg = 0;
		}
	}

	printf("Finish training!\n");
	torch::serialize::OutputArchive archive;
	decoder.save(archive);
	archive.save_to("..\\retModel\\char-rnn-shakespeare-c++.pt");
	printf("Save the training result to ..\\char-rnn-shakespeare-c++.pt.\n");

#else		//推理
	RNN decoder(n_characters, hidden_size, n_characters, n_layers);

	torch::serialize::InputArchive archive;
	archive.load_from("..\\retModel\\char-rnn-shakespeare-c++.pt");

	decoder.load(archive);

	std::string prime_str = "Anger";
	cout << endl << generate(prime_str, decoder, device, 200, 0.8) << endl;

#endif;
	return 0;
}

2.网络结构

struct RNN : public torch::nn::Module
{
	//n_characters, hidden_size, n_characters, n_layers
	RNN(int input_size, int hidden_size, int output_size, int n_layers)
	{
		m_input_size = input_size;
		m_hidden_size = hidden_size;
		m_output_size = output_size;
		m_n_layers = n_layers;

		encoder = register_module("encoder", torch::nn::Embedding(input_size, hidden_size));
		gru = register_module("gru", torch::nn::GRU(torch::nn::GRUOptions(hidden_size, hidden_size).num_layers(n_layers)));
		decoder = register_module("decoder", torch::nn::Linear(hidden_size, output_size));
	}
	~RNN()
	{

	}

	std::tuple<torch::Tensor, torch::Tensor> forward(torch::Tensor input, torch::Tensor hidden)
	{
		m_input = encoder(input.view({ 1, -1 }));
		std::tuple<torch::Tensor, torch::Tensor> retgru = gru(m_input.view({ 1, 1, -1 }), hidden);
		m_output = std::get<0>(retgru);
		m_hidden = std::get<1>(retgru);
		m_output = decoder(m_output.view({ 1, -1 }));
		return { m_output, m_hidden };
	}

	torch::Tensor initHidden()
	{
		return torch::zeros({ m_n_layers, 1, m_hidden_size });
	}

	int m_n_layers = 0;
	int m_input_size = 0;
	int m_hidden_size = 0;
	int m_output_size = 0;

	torch::nn::Embedding encoder{ nullptr };
	torch::nn::GRU gru{ nullptr };
	torch::nn::Linear decoder{ nullptr };
	torch::Tensor m_input, m_output, m_hidden;
};

3.训练

/*作者:barcaFC											*/
/*日期:2022-11-10										*/
/*函数:random_training_set								*/
/*功能:inp从0-倒数第二字符 target从1到最后一个字符		*/
/*输入:chunk_len要读取多少字符							*/
/*输出:输出inp和target的tensor	送入wordEmbedding		*/

std::tuple<torch::Tensor, torch::Tensor> random_training_set(int chunk_len)
{
	torch::Tensor inp, target;

	int start_index = rand() % gfilelen;
	int end_index = start_index + chunk_len + 1;

	std::string chunk = gfile.substr(start_index, end_index);

	inp = char_tensor(chunk.substr(start_index, chunk_len));
	target = char_tensor(chunk.substr(start_index + 1, chunk_len + 1));

	return { inp ,target };
}

torch::Tensor train(RNN& decoder, torch::Device device,
	torch::Tensor inp, torch::Tensor target,
	torch::optim::Optimizer& decoder_optimizer, torch::nn::CrossEntropyLoss& criterion)
{
	decoder.to(device);
	decoder.train(true);

	torch::Tensor hidden = decoder.initHidden();
	decoder_optimizer.zero_grad();

	torch::Tensor loss = torch::zeros({ 1 }, torch::kFloat64);
	torch::Tensor output;
	for (int c = 0; c < chunk_len; c++)
	{
		//cout << "inp[c].data.size : " << endl;
		//cout << inp[c].data().sizes() << endl;
		std::tuple<torch::Tensor, torch::Tensor> retTrain = decoder.forward(inp[c], hidden);
		output = std::get<0>(retTrain);
		hidden = std::get<1>(retTrain);

		try
		{
			torch::Tensor temp = torch::zeros({ 1 }, torch::kLong);
			temp[0] = target[c].item().toLong();
			loss += criterion(output, temp);
		}
		catch (const c10::Error& e)
		{
			std::cout << "criterion an error has occured : " << e.msg() << std::endl;
			return loss;
		}
	}

	loss.backward();
	decoder_optimizer.step();

	return loss;
}

4.生成

std::string generate(std::string prime_str, RNN& decoder, torch::Device device, int predict_len, float temperature)
{
	decoder.to(device);
	decoder.train(false);

	torch::Tensor hidden = decoder.initHidden();
	torch::Tensor prime_input = char_tensor(prime_str);

	std::string predicted = prime_str;

	//Use priming string to "build up" hidden state
	for (int p = 0; p < prime_str.length(); p++)
	{
		std::tuple<torch::Tensor, torch::Tensor> retHidden = decoder.forward(prime_input[p], hidden);
		hidden = std::get<1>(retHidden);
	}

	torch::Tensor inp = prime_input[prime_str.length() - 1];
	torch::Tensor output;
	for (int c = 0; c < predict_len; c++)
	{
		std::tuple<torch::Tensor, torch::Tensor> retDecoder = decoder.forward(inp, hidden);
		output = std::get<0>(retDecoder);
		hidden = std::get<1>(retDecoder);

		//Sample from the network as a multinomial distribution
		torch::Tensor output_dist = output.data().view(-1).div(temperature).exp();
		torch::Tensor top_i = torch::multinomial(output_dist, 1)[0];

		//Add predicted character to string and use as next input
		char predicted_char = all_characters.at(top_i.item().toInt());
		predicted += predicted_char;
		std::string strINP;
		strINP = predicted_char;
		inp = char_tensor(strINP);
	}

	return predicted;
}

5.辅助函数

std::string all_characters = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!\"#$%&'()*+, -./:;<=>?@[\]^_`{|}~";
int n_characters = all_characters.length();

int gfilelen = 0;
std::string gfile;

BOOL read_file(const wchar_t * pwszFilePath)
{
	ifstream fin;
	std::string str;
	fin.open(pwszFilePath, ios::in);

	fin.seekg(0, ios::end);
	gfilelen = fin.tellg();
	fin.seekg(0, ios::beg);

	if (!fin.is_open())
	{
		cout << "无法找到这个文件！" << endl;
		return FALSE;
	}

	while (getline(fin, str))
	{
		gfile += str;
	}
	
	fin.close();

	return TRUE;
}

torch::Tensor char_tensor(std::string str)
{
	LONGLONG len = str.length();
	//cout << "str : " << str << endl;

	torch::Tensor tensor = torch::zeros({ len }, torch::kLong);
	for (int c = 0; c < len; c++)
		tensor[c] = (LONG)all_characters.find(str[c]);

	//cout << "char_tensor sizes===>:" << endl;
	//cout << tensor.sizes() << endl;
	//cout << tensor << endl;
	return tensor;
}

总结

内容生成(AIGC)是目前炙手可热的AI分支，内容生成不仅仅是能够生成训练内容，也是一种迭代逼近某种解析解(具有无限解空间的最优解)的方法。将内容生成和其他提取类模型相结合，能够辅助完成非常多之前需要大量人力物力的工作。

barcaFC
关注
  • 0
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Pytorch模型部署 - Libtorch(crnn模型部署)
a1040193597的博客
03-21 6746
Pytorch模型部署 - Libtorch 简介 libtorch是facebook提供的一套C++推理接口库，便于工业级别部署和性能优化。 安装： libtoch+opencv联合编译，这里采用libtorch-1.4(cpu)+opencv4.1． 可能出现的问题 ibtoch,opencv联合编译项目时，报错Undefined reference to cv::imread(std:...
pytorch版crnn网络框架
weixin_52646021的博客
12-15 1846
这是我们常见的pytorch版的crnn网络框架，我遵循老师的想法，用C++和libtorch也搭建了一个一模一样的框架，主要是用来部署用的，我暂时把libtorch版本的代码放到了私密文章里面，还没有公开，有需要的私信我 import torch.nn as nn import torch.nn.functional as F from collections import OrderedDict class BidirectionalLSTM(nn.Module): # Inputs hidde
pytorch基于RNN实现文本情感分析并用C++加载模型预测
踏莎行的博客
07-08 2284
文本情感分析是机器学习自然语言处理NLP中常见的应用场景，给定一段文本，识别其中的情绪或态度，对其进行分类并标签化。这个手段可以应用于书籍电影评价、用户对产品满意度调查、人机对话感情色彩提取和金融研报分析。 本文以美国IMDB电影网站的评论数据为例，用pytorch构建和训练基于循环神经网络LSTM的模型，然后用C++ libtorch加载模型对于给定的电影评论文本进行预测，判断改评论是正面的还是负面的，代码和数据实例参考了动手学机器学习pytorch版 环境 开发工具 windows7/ubunt
RNN在自然语言处理中的应用及其PyTorch实现
CSDN人工智能
11-28 1万+
对于人类而言，以前见过的事物会在脑海里面留下记忆，虽然随后记忆会慢慢消失，但是每当经过提醒，人们往往能够重拾记忆。在神经网络的研究中，让模型充满记忆力的研究很早便开始了，Saratha Sathasivam 于1982 年提出了霍普菲尔德网络，但是由于它实现困难，在提出的时候也没有很好的应用场景，所以逐渐被遗忘。深度学习的兴起又让人们重新开始研究循环神经网络（Recurrent Neural Network），并在序
pytorch从头开始实现一个RNN(循环神经网络)
weixin_34198453的博客
11-14 1721
2019独角兽企业重金招聘Python工程师标准>>> ...
text-classification-cnn-rnn-master_RNN_CNN_
10-02
标题中的"RNN_CNN"表明这是一个结合循环神经网络（Recurrent Neural Network, RNN）与卷积神经网络（Convolutional Neural Network, CNN）的项目，用于中文文本分类。在描述中，我们得知该实现是用TensorFlow完成的...
libtorch-win-shared-with-deps-1.5.0+cpu.zip
07-21
3. 构建模型：利用torch::nn模块，可以构建深度学习模型，如卷积神经网络（CNN）、循环神经网络（RNN）等。 4. 训练与优化：通过定义损失函数和优化器，可以实现模型的训练过程。libtorch提供了常见的损失函数和...
chinese-char-rnn：字符级语言模型
02-03
汉字级语言模型 递归神经网络（LSTM，GRU，RWA）用于Tensorflow中的字符级语言模型，任务是在给定句子中先前字符的历史的情况下预测下一个字符，在vocab时使用nce-loss来加速多类分类数据量巨大，数据集是每天从香港...
Python-用TensorFlow实现的CharRNN
08-11
`tensorflow-char-rnn-master`项目可能包含以下关键文件： - `model.py`：定义CharRNN模型结构 - `train.py`：训练模型 - `sample.py`：使用训练好的模型生成新文本 - `data.py`：处理和加载数据 通过这个项目...
a-important-rnn-2015-RNN应用-KarparthyUNREASONABLY-EFFECTIVE-RNN-1
08-03
《RNN应用：Karparthy的“不合理但有效”RNN》 在神经网络的世界里，循环神经网络（RNN）具有独特的魅力。2015年，作者首次尝试用RNN进行图像描述生成时，即便是在参数设置相对随意的情况下，经过短短几十分钟的...
wtte-rnn：WTTE-RNN：流失和事件预测时间的框架
02-06
WTTE-RNN是一种算法和关于如何实现的哲学。快速直观的介绍Jupyter笔记本：，Gianmario Spacagna的“故障时间”。 韩文安装Python查看。 如果这看起来，则可以将其作为内嵌式内联找到思想和基础您具有包含许多时间...
RNN_LSTM-master.zip_LSTM-MATLAB-master_RNN_RNN-LSTM-master_RNN_L
07-14
description de code RNN LSTM
Singing-Voice-Separation-RNN:使用深度递归神经网络将单声道录音中的声音与声音分离
05-10
歌声分离RNN 雷茂 芝加哥大学 介绍 这是使用递归神经网络（RNN）开发的歌声分离工具。 它可以将歌手的声音和背景音乐与原始歌曲区分开。 由于分离尚不完善，因此它仍处于开发阶段。 请检查演示的性能。 依存关系 的...
ny-stock-price-prediction-rnn-lstm-gru.rar
最新发布
06-20
标题中的“ny-stock-price-prediction-rnn-lstm-gru.rar”表明这是一个关于纽约股票价格预测的项目，其中使用了循环神经网络（RNN）、长短时记忆网络（LSTM）和门控循环单元（GRU）这三种深度学习模型。在金融领域，...
使用torch实现RNN
思念殇千寻的博客
09-27 2858
　　（本文对https://blog.csdn.net/out_of_memory_error/article/details/81456501的结果进行了复现。） 　　在实验室的项目遇到了困难，弄不明白LSTM的原理。到网上搜索，发现LSTM是RNN的变种，那就从RNN开始学吧。 　　带隐藏状态的RNN可以用下面两个公式来表示： 　　可以看出，一个RNN的参数有W_xh，W_hh...
windows c++下使用libtorch导入pytorch模型
ZHUYOUKANG的博客
03-18 2267
一.下载libtorch 到官网pytorch官网下载libtorch,选择适合自己版本pytorch官网.下方有相应的下载链接,一个debug版本,一个release版本 目前我是使用的pytorch也是1.4版本,之前网上查阅资料时,有人说下载的libtorch版本要跟pytorch版本一致,不一致的情况我也没试. 本人环境: 系统 :ubuntu16.4 && win10 p...
PyTorch基础入门七：PyTorch搭建循环神经网络(RNN)
热门推荐
Liam的个人博客
08-06 2万+
1）任务介绍 今天，我们通过PyTorch搭建一个用于处理序列的RNN。 当我们以sin值作为输入，其对应的cos作为输出的时候，你会发现，即使输入值sin相同，其输出结果也可以是不同的，这样的话，以前学过的FC, CNN就难以处理，因为你的输出结果不仅仅依赖于输出，而且还依赖于之前的程序结果。所以说，RNN在这里就派上了用场。 2）代码实现 上代码之前，还是先了解一下RNN的参数吧：...
深度学习笔记（五）用Torch实现RNN来制作一个神经网络计时器
山猫小队长的专栏
11-06 6154
本节代码地址 https://github.com/vic-w/torch-practice/tree/master/rnn-timer 现在终于到了激动人心的时刻了。我最初选用Torch的目的就是为了学习RNN。RNN全称Recurrent Neural Network（卷积神经网络），是通过在网络中增加回路而使其具有记忆功能。对自然语言处理，图像识别等方面都有深远影响。 这次
ARIMA SARIMA VAR Auto-ARIMA Auto-SARIMA LSTM GRU RNN CNN MLP DNN MLP-LSTM MLP-GRU MLP-RNN MLP-CNN LSTM-ARIMA LSTM-MLP LSTM-CNN GRU-ARIMA GRU-MLP GRU-CNN RNN-ARIMA RNN-MLP RNN-CNN CNN-ARIMA CNN-MLP CNN-LSTM CNN-GRU ARIMA-SVM SARIMA-SVM VAR-SVM Auto-ARIMA-SVM Auto-SARIMA-SVM LSTM-SVM GRU-SVM RNN-SVM CNN-SVM MLP-SVM LSTM-ARIMA-SVM LSTM-MLP-SVM LSTM-CNN-SVM GRU-ARIMA-SVM GRU-MLP-SVM GRU-CNN-SVM RNN-ARIMA-SVM RNN-MLP-SVM RNN-CNN-SVM CNN-ARIMA-SVM CNN-MLP-SVM CNN-LSTM-SVM CNN-GRU-SVM ARIMA-RF SARIMA-RF VAR-RF Auto-ARIMA-RF Auto-SARIMA-RF LSTM-RF GRU-RF RNN-RF CNN-RF MLP-RF LSTM-ARIMA-RF LSTM-MLP-RF LSTM-CNN-RF GRU-ARIMA-RF GRU-MLP-RF GRU-CNN-RF RNN-ARIMA-RF RNN-MLP-RF RNN-CNN-RF CNN-ARIMA-RF CNN-MLP-RF CNN-LSTM-RF CNN-GRU-RF ARIMA-XGBoost SARIMA-XGBoost VAR-XGBoost Auto-ARIMA-XGBoost Auto-SARIMA-XGBoost LSTM-XGBoost GRU-XGBoost RNN-XGBoost CNN-XGBoost MLP-XGBoost LSTM-ARIMA-XGBoost LSTM-MLP-XGBoost LSTM-CNN-XGBoost GRU-ARIMA-XGBoost GRU-MLP-XGBoost GRU-CNN-XGBoost RNN-ARIMA-XGBoost RNN-MLP-XGBoost RNN-CNN-XGBoost CNN-ARIMA-XGBoost CNN-MLP-XGBoost CNN-LSTM-XGBoost CNN-GRU-XGBoost ARIMA-ANN SARIMA-ANN VAR-ANN 上面这100个缩写模型的全称及相关用途功能详细解释
07-15
以下是对上述100个缩写模型的全称及相关用途功能的详细解释： 1. ARIMA (AutoRegressive Integrated Moving Average): 适用于平稳时间序列数据的预测，结合了自回归 (AR) 和移动平均 (MA) 的模型。 2. SARIMA (Seasonal ARIMA): 在ARIMA模型基础上添加了对季节性因素的建模，适用于带有季节性的时间序列数据的预测。 3. VAR (Vector Autoregression): 用于多变量时间序列数据的预测，基于自回归模型，能够捕捉变量之间的相互依赖关系。 4. Auto-ARIMA: 自动选择ARIMA模型的参数，通过对多个模型进行评估和选择来实现自动化。 5. Auto-SARIMA: 自动选择SARIMA模型的参数，通过对多个模型进行评估和选择来实现自动化。 6. LSTM (Long Short-Term Memory): 长短期记忆网络，一种适用于处理长期依赖关系的循环神经网络，用于时间序列数据的建模和预测。 7. GRU (Gated Recurrent Unit): 一种类似于LSTM的循环神经网络，具有更简化的结构，适用于时间序列数据的建模和预测。 8. RNN (Recurrent Neural Network): 适用于处理序列数据的神经网络模型，能够捕捉时间序列的动态特性。 9. CNN (Convolutional Neural Network): 卷积神经网络，主要用于图像处理，但也可以用于时间序列数据的预测，特别擅长局部模式的识别
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值