LSTM进行字符级文本生成_3(pytorch实现)

文章目录
  • 基于pytorch的LSTM进行字符集文本生成
  • 前言
  • 一、数据集
  • 二、代码实现
    • 1.到入库和LSTM进行模型构建
    • 2.数据预处理函数
    • 3.训练函数
    • 4.预测函数
    • 5.文本生成函数
    • 6.主函数
  • 完整代码
  • 总结

前言

本文介绍了机器学习中深度学习的内容使用pytorch构建LSTM模型进行字符级文本生成任务

一、数据集

https://download.csdn.net/download/qq_52785473/78428834

二、代码实现

1.导入库及LSTM模型构建

代码如下:

# coding: utf-8
import torch
import torch.nn as nn
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import OneHotEncoder
import torch.nn.functional as Fclass lstm_model(nn.Module):def __init__(self, vocab, hidden_size, num_layers, dropout=0.5):super(lstm_model, self).__init__()self.vocab = vocab  # 字符数据集# 索引,字符self.int_char = {i: char for i, char in enumerate(vocab)}self.char_int = {char: i for i, char in self.int_char.items()}# 对字符进行one-hot encodingself.encoder = OneHotEncoder(sparse=True).fit(vocab.reshape(-1, 1))self.hidden_size = hidden_sizeself.num_layers = num_layers# lstm层self.lstm = nn.LSTM(len(vocab), hidden_size, num_layers, batch_first=True, dropout=dropout)# 全连接层self.linear = nn.Linear(hidden_size, len(vocab))def forward(self, sequence, hs=None):out, hs = self.lstm(sequence, hs)  # lstm的输出格式(batch_size, sequence_length, hidden_size)out = out.reshape(-1, self.hidden_size)  # 这里需要将out转换为linear的输入格式,即(batch_size * sequence_length, hidden_size)output = self.linear(out)  # linear的输出格式,(batch_size * sequence_length, vocab_size)return output, hsdef onehot_encode(self, data):  # 对数据进行编码return self.encoder.transform(data)def onehot_decode(self, data):  # 对数据进行解码return self.encoder.inverse_transform(data)def label_encode(self, data):  # 对标签进行编码return np.array([self.char_int[ch] for ch in data])def label_decode(self, data):  # 对标签进行解码return np.array([self.int_char[ch] for ch in data])

2.数据预处理函数

def get_batches(data, batch_size, seq_len):''':param data: 源数据,输入格式(num_samples, num_features):param batch_size: batch的大小:param seq_len: 序列的长度(精度):return: (batch_size, seq_len, num_features)'''num_features = data.shape[1]num_chars = batch_size * seq_len  # 一个batch_size的长度num_batches = int(np.floor(data.shape[0] / num_chars))  # 计算出有多少个batchesneed_chars = num_batches * num_chars  # 计算出需要的总字符量targets = np.vstack((data[1:].A, data[0].A))  # 可能版本问题,取成numpy比较好reshapeinputs = data[:need_chars].A.astype("int")  # 从原始数据data中截取所需的字符数量need_wordstargets = targets[:need_chars]targets = targets.reshape(batch_size, -1, num_features)inputs = inputs.reshape(batch_size, -1, num_features)for i in range(0, inputs.shape[1], seq_len):x = inputs[:, i: i+seq_len]y = targets[:, i: i+seq_len]yield x, y  # 节省内存

3.训练函数

def train(model, data, batch_size, seq_len, epochs, lr=0.01, valid=None):device = 'cuda' if torch.cuda.is_available() else 'cpu'model = model.to(device)optimizer = torch.optim.Adam(model.parameters(), lr=lr)criterion = nn.CrossEntropyLoss()if valid is not None:data = model.onehot_encode(data.reshape(-1, 1))valid = model.onehot_encode(valid.reshape(-1, 1))else:data = model.onehot_encode(data.reshape(-1, 1))train_loss = []val_loss = []for epoch in range(epochs):model.train()hs = None  # hs等于hidden_size隐藏层节点train_ls = 0.0val_ls = 0.0for x, y in get_batches(data, batch_size, seq_len):optimizer.zero_grad()x = torch.tensor(x).float().to(device)out, hs = model(x, hs)hs = ([h.data for h in hs])y = y.reshape(-1, len(model.vocab))y = model.onehot_decode(y)y = model.label_encode(y.squeeze())y = torch.from_numpy(y).long().to(device)loss = criterion(out, y.squeeze())loss.backward()optimizer.step()train_ls += loss.item()if valid is not None:model.eval()hs = Nonewith torch.no_grad():for x, y in get_batches(valid, batch_size, seq_len):x = torch.tensor(x).float().to(device)  # x为一组测试数据,包含batch_size * seq_len个字out, hs = model(x, hs)# out.shape输出为tensor[batch_size * seq_len, vocab_size]hs = ([h.data for h in hs])  # 更新参数y = y.reshape(-1, len(model.vocab))  # y.shape为(128,100,43),因此需要转成两维,每行就代表一个字了,43为字典大小y = model.onehot_decode(y)  # y标签即为测试数据各个字的下一个字,进行one_hot解码,即变为字符# 但是此时y 是[[..],[..]]形式y = model.label_encode(y.squeeze())  # 因此需要去掉一维才能成功解码# 此时y为[12...]成为一维的数组,每个代表自己字典里对应字符的字典序y = torch.from_numpy(y).long().to(device)# 这里y和y.squeeze()出来的东西一样,可能这里没啥用,不太懂loss = criterion(out, y.squeeze())  # 计算损失值val_ls += loss.item()val_loss.append(np.mean(val_ls))train_loss.append(np.mean(train_ls))print("train_loss:", train_ls)plt.plot(train_loss, label="train_loss")plt.plot(val_loss, label="val loss")plt.title("loop vs epoch")plt.legend()plt.show()model_name = "lstm_model.net"with open(model_name, 'wb') as f:  # 训练完了保存模型torch.save(model.state_dict(), f)

4.预测函数

def predict(model, char, top_k=None, hidden_size=None):device = 'cuda' if torch.cuda.is_available() else 'cpu'model.to(device)model.eval()  # 固定参数with torch.no_grad():char = np.array([char])  # 输入一个字符,预测下一个字是什么,先转成numpychar = char.reshape(-1, 1)  # 变成二维才符合编码规范char_encoding = model.onehot_encode(char).A  # 对char进行编码,取成numpy比较方便reshapechar_encoding = char_encoding.reshape(1, 1, -1)  # char_encoding.shape为(1, 1, 43)变成三维才符合模型输入格式char_tensor = torch.tensor(char_encoding, dtype=torch.float32)  # 转成tensorchar_tensor = char_tensor.to(device)out, hidden_size = model(char_tensor, hidden_size)  # 放入模型进行预测,out为结果probs = F.softmax(out, dim=1).squeeze()  # 计算预测值,即所有字符的概率if top_k is None:  # 选择概率最大的top_k个indices = np.arange(vocab_size)else:probs, indices = probs.topk(top_k)indices = indices.cpu().numpy()probs = probs.cpu().numpy()char_index = np.random.choice(indices, p=probs/probs.sum())  # 随机选择一个字符索引作为预测值char = model.int_char[char_index]  # 通过索引找出预测字符return char, hidden_size

5.文本生成函数

def sample(model, length, top_k=None, sentence="c"):hidden_size = Nonenew_sentence = [char for char in sentence]for i in range(length):next_char, hidden_size = predict(model, new_sentence[-1], top_k=top_k, hidden_size=hidden_size)new_sentence.append(next_char)return "".join(new_sentence)

6.主函数

def main():hidden_size = 512num_layers = 2batch_size = 128seq_len = 100epochs = 2lr = 0.01f = pd.read_csv("../datasets/dev.tsv", sep="\t", header=None)f = f[0]text = list(f)text = ".".join(text)vocab = np.array(sorted(set(text)))  # 建立字典vocab_size = len(vocab)val_len = int(np.floor(0.2 * len(text)))  # 划分训练测试集trainset = np.array(list(text[:-val_len]))validset = np.array(list(text[-val_len:]))model = lstm_model(vocab, hidden_size, num_layers)  # 模型实例化train(model, trainset, batch_size, seq_len, epochs, lr=lr, valid=validset)  # 训练模型model.load_state_dict(torch.load("lstm_model.net"))  # 调用保存的模型new_text = sample(model, 100, top_k=5)  # 预测模型,生成100个字符,预测时选择概率最大的前5个print(new_text)  # 输出预测文本if __name__ == "__main__":main()

本代码还是有很大改进空间,例如进行词语级的文本生成,以及使用word2vec等引入词向量等,都可以是的模型获得更好的效果。

完整代码

# coding: utf-8
import torch
import torch.nn as nn
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import OneHotEncoder
import torch.nn.functional as Fclass lstm_model(nn.Module):def __init__(self, vocab, hidden_size, num_layers, dropout=0.5):super(lstm_model, self).__init__()self.vocab = vocab  # 字符数据集# 索引,字符self.int_char = {i: char for i, char in enumerate(vocab)}self.char_int = {char: i for i, char in self.int_char.items()}# 对字符进行one-hot encodingself.encoder = OneHotEncoder(sparse=True).fit(vocab.reshape(-1, 1))self.hidden_size = hidden_sizeself.num_layers = num_layers# lstm层self.lstm = nn.LSTM(len(vocab), hidden_size, num_layers, batch_first=True, dropout=dropout)# 全连接层self.linear = nn.Linear(hidden_size, len(vocab))def forward(self, sequence, hs=None):out, hs = self.lstm(sequence, hs)  # lstm的输出格式(batch_size, sequence_length, hidden_size)out = out.reshape(-1, self.hidden_size)  # 这里需要将out转换为linear的输入格式,即(batch_size * sequence_length, hidden_size)output = self.linear(out)  # linear的输出格式,(batch_size * sequence_length, vocab_size)return output, hsdef onehot_encode(self, data):return self.encoder.transform(data)def onehot_decode(self, data):return self.encoder.inverse_transform(data)def label_encode(self, data):return np.array([self.char_int[ch] for ch in data])def label_decode(self, data):return np.array([self.int_char[ch] for ch in data])def get_batches(data, batch_size, seq_len):''':param data: 源数据,输入格式(num_samples, num_features):param batch_size: batch的大小:param seq_len: 序列的长度(精度):return: (batch_size, seq_len, num_features)'''num_features = data.shape[1]num_chars = batch_size * seq_len  # 一个batch_size的长度num_batches = int(np.floor(data.shape[0] / num_chars))  # 计算出有多少个batchesneed_chars = num_batches * num_chars  # 计算出需要的总字符量targets = np.vstack((data[1:].A, data[0].A))  # 可能版本问题,取成numpy比较好reshapeinputs = data[:need_chars].A.astype("int")  # 从原始数据data中截取所需的字符数量need_wordstargets = targets[:need_chars]targets = targets.reshape(batch_size, -1, num_features)inputs = inputs.reshape(batch_size, -1, num_features)for i in range(0, inputs.shape[1], seq_len):x = inputs[:, i: i+seq_len]y = targets[:, i: i+seq_len]yield x, y  # 节省内存def train(model, data, batch_size, seq_len, epochs, lr=0.01, valid=None):device = 'cuda' if torch.cuda.is_available() else 'cpu'model = model.to(device)optimizer = torch.optim.Adam(model.parameters(), lr=lr)criterion = nn.CrossEntropyLoss()if valid is not None:data = model.onehot_encode(data.reshape(-1, 1))valid = model.onehot_encode(valid.reshape(-1, 1))else:data = model.onehot_encode(data.reshape(-1, 1))train_loss = []val_loss = []for epoch in range(epochs):model.train()hs = None  # hs等于hidden_size隐藏层节点train_ls = 0.0val_ls = 0.0for x, y in get_batches(data, batch_size, seq_len):optimizer.zero_grad()x = torch.tensor(x).float().to(device)out, hs = model(x, hs)hs = ([h.data for h in hs])y = y.reshape(-1, len(model.vocab))y = model.onehot_decode(y)y = model.label_encode(y.squeeze())y = torch.from_numpy(y).long().to(device)loss = criterion(out, y.squeeze())loss.backward()optimizer.step()train_ls += loss.item()if valid is not None:model.eval()hs = Nonewith torch.no_grad():for x, y in get_batches(valid, batch_size, seq_len):x = torch.tensor(x).float().to(device)  # x为一组测试数据,包含batch_size * seq_len个字out, hs = model(x, hs)# out.shape输出为tensor[batch_size * seq_len, vocab_size]hs = ([h.data for h in hs])  # 更新参数y = y.reshape(-1, len(model.vocab))  # y.shape为(128,100,43),因此需要转成两维,每行就代表一个字了,43为字典大小y = model.onehot_decode(y)  # y标签即为测试数据各个字的下一个字,进行one_hot解码,即变为字符# 但是此时y 是[[..],[..]]形式y = model.label_encode(y.squeeze())  # 因此需要去掉一维才能成功解码# 此时y为[12...]成为一维的数组,每个代表自己字典里对应字符的字典序y = torch.from_numpy(y).long().to(device)# 这里y和y.squeeze()出来的东西一样,可能这里没啥用,不太懂loss = criterion(out, y.squeeze())  # 计算损失值val_ls += loss.item()val_loss.append(np.mean(val_ls))train_loss.append(np.mean(train_ls))print("train_loss:", train_ls)plt.plot(train_loss, label="train_loss")plt.plot(val_loss, label="val loss")plt.title("loop vs epoch")plt.legend()plt.show()model_name = "lstm_model.net"with open(model_name, 'wb') as f:  # 训练完了保存模型torch.save(model.state_dict(), f)def predict(model, char, top_k=None, hidden_size=None):device = 'cuda' if torch.cuda.is_available() else 'cpu'model.to(device)model.eval()  # 固定参数with torch.no_grad():char = np.array([char])  # 输入一个字符,预测下一个字是什么,先转成numpychar = char.reshape(-1, 1)  # 变成二维才符合编码规范char_encoding = model.onehot_encode(char).A  # 对char进行编码,取成numpy比较方便reshapechar_encoding = char_encoding.reshape(1, 1, -1)  # char_encoding.shape为(1, 1, 43)变成三维才符合模型输入格式char_tensor = torch.tensor(char_encoding, dtype=torch.float32)  # 转成tensorchar_tensor = char_tensor.to(device)out, hidden_size = model(char_tensor, hidden_size)  # 放入模型进行预测,out为结果probs = F.softmax(out, dim=1).squeeze()  # 计算预测值,即所有字符的概率if top_k is None:  # 选择概率最大的top_k个indices = np.arange(vocab_size)else:probs, indices = probs.topk(top_k)indices = indices.cpu().numpy()probs = probs.cpu().numpy()char_index = np.random.choice(indices, p=probs/probs.sum())  # 随机选择一个字符索引作为预测值char = model.int_char[char_index]  # 通过索引找出预测字符return char, hidden_sizedef sample(model, length, top_k=None, sentence="c"):hidden_size = Nonenew_sentence = [char for char in sentence]for i in range(length):next_char, hidden_size = predict(model, new_sentence[-1], top_k=top_k, hidden_size=hidden_size)new_sentence.append(next_char)return "".join(new_sentence)def main():hidden_size = 512num_layers = 2batch_size = 128seq_len = 100epochs = 2lr = 0.01f = pd.read_csv("../datasets/dev.tsv", sep="\t", header=None)f = f[0]text = list(f)text = ".".join(text)vocab = np.array(sorted(set(text)))  # 建立字典vocab_size = len(vocab)val_len = int(np.floor(0.2 * len(text)))  # 划分训练测试集trainset = np.array(list(text[:-val_len]))validset = np.array(list(text[-val_len:]))model = lstm_model(vocab, hidden_size, num_layers)  # 模型实例化train(model, trainset, batch_size, seq_len, epochs, lr=lr, valid=validset)  # 训练模型model.load_state_dict(torch.load("lstm_model.net"))  # 调用保存的模型new_text = sample(model, 100, top_k=5)  # 预测模型,生成100个字符,预测时选择概率最大的前5个print(new_text)  # 输出预测文本if __name__ == "__main__":main()

总结

这个案例他数据预处理的时候,一个序列对应一个序列的关系,例如abcd对应的标签为dabc,而不是一个字符,因此可能后面进行了某些操作使得他变成一个字符对应一个字符标签的操作了吧,从而使得预测的时候,只能通过一个字符预测其后面的字符,这就有点失去循环神经网络精髓的味道了,感觉是割裂字符之间的关系,变成一个普通单纯的分类了。

循环神经网络,因为能够处理序列位置的信息,需要设定一个滑动窗口值,或者说时间步长什么的,作用应该就是保留序列特征,例如abcdef为训练数据,设置滑动窗口为3的话,那么按照正常的序列思路可以划分为abc-d、bcd-e、cde-f作为训练数据的形式,即连续的三个字符对应的标签为其后面一个字符,那么我们训练出来的模型也是需要输入三个字符,然后生成一个字符,再用预测出来的字符加上他前面两个字符再预测新的字符,例如预测的初始序列为abc加入abc预测出来d,那么下一次预测就是bcd作为输入,就像一个窗口一步一步滑动过去一样,窗口的大小就为开始设定的3。

因此对于这个案例,它虽然seq_len=100,即滑动窗口为100,但是它的训练数据就不太对,而且模型预测时也是一个字符预测下一个字符,并没有体现滑动窗口的思想,因此这个代码案例大家可以自己进行改进优化。

下面是对代码部分地方的改动,使得它能够按滑动窗口的思维来进行训练和预测

数据预处理函数

def get_batches(data, batch_size, seq_len):''':param data: 源数据,输入格式(num_samples, num_features):param batch_size: batch的大小:param seq_len: 序列的长度(精度):return: (batch_size, seq_len, num_features)'''num_features = data.shape[1]num_chars = batch_size * seq_len  # 一个batch_size的长度num_batches = int(np.floor(data.shape[0] / num_chars))  # 计算出有多少个batchesneed_chars = num_batches * num_chars  # 计算出需要的总字符量targets = np.vstack((data[1:].A, data[0].A))  # 可能版本问题,取成numpy比较好reshapeinputs = data[:need_chars].A.astype("int")  # 从原始数据data中截取所需的字符数量need_wordstargets = targets[:need_chars]train_data = np.zeros((inputs.shape[0] - seq_len, seq_len, num_features))train_label = np.zeros((inputs.shape[0] - seq_len, num_features))for i in range(0, inputs.shape[0] - seq_len, 1):# inputs就是字符数 * 词向量大小(表示一个字符)# 思路就是abcd中ab-c, bc-d,一共4-3+1个train_data[i] = inputs[i:i+seq_len]  # 每seq_len=100的字符train_label[i] = inputs[i+seq_len-1] # 训练标签就为他后面那个字符print(train_data.shape)print(train_label.shape)for i in range(0, inputs.shape[0] - seq_len, batch_size):  x = train_data[i:i+batch_size] # 每batch_size=128个一起进行训练更新参数y = train_label[i:i+batch_size]  # 对应的128个标签print(x.shape)print(y.shape)print("-----------")yield x, y

模型构建部分

class lstm_model(nn.Module):def __init__(self, vocab, hidden_size, num_layers, dropout=0.5, seq_len=100):super(lstm_model, self).__init__()self.seq_len = seq_lenself.vocab = vocab  # 字符数据集# 索引,字符self.int_char = {i: char for i, char in enumerate(vocab)}self.char_int = {char: i for i, char in self.int_char.items()}# 对字符进行one-hot encodingself.encoder = OneHotEncoder(sparse=True).fit(vocab.reshape(-1, 1))self.hidden_size = hidden_sizeself.num_layers = num_layers# lstm层self.lstm = nn.LSTM(len(vocab), hidden_size, num_layers, batch_first=True, dropout=dropout)# 全连接层self.linear = nn.Linear(hidden_size, len(vocab))def forward(self, sequence, hs=None):# print("==========")# print("forward:", sequence.shape)out, hs = self.lstm(sequence, hs)  # lstm的输出格式(batch_size, sequence_length, hidden_size)print("----", out.shape)# out = out.reshape(-1, self.hidden_size)  # 这里需要将out转换为linear的输入格式,即(batch_size * sequence_length, hidden_size)print("========", out[:, -1].shape)output = self.linear(out[:, -1])  # 只取[bacth_size,hidden_size],即找到batch_size里每个元素的标签吧print("output-----:", output.shape)return output, hsdef onehot_encode(self, data):return self.encoder.transform(data)def onehot_decode(self, data):return self.encoder.inverse_transform(data)def label_encode(self, data):return np.array([self.char_int[ch] for ch in data])def label_decode(self, data):return np.array([self.int_char[ch] for ch in data])

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

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

尝试各种可以联网的AI

phind https://www.phind.com/ 搜索次数限制:无 右侧显示搜索引用文章地址链接以及大致内容缩略显示 左侧显示总结 perplexity https://www.perplexity.ai/ 搜索次数限制:每四小时5次搜索 内容上下分层,样式如下: Sources 显示…

一篇长文教你进行全方位的使用appium【建议收藏】

随着移动应用的日益普及,移动应用的测试成为了软件开发的重要组成部分。Python,作为一种易于学习,功能强大的编程语言,特别适合进行这种测试。本文将详细介绍如何使用Python进行APP测试,并附带一个实例。 Python 和 A…

OPCUA 学习笔记-程序模型

无论是边缘控制器,还是PLC 中,除了信息模型之外,还有应用程序,这些程序可能是IEC61131-3 编写的程序,也可能是其它程序开发的可执行程序。 尽管OPCUA 描述模型能力很强,但是它缺乏算法的描述方式。但是OPCU…

qnx启动

bmetrics_service boot metrics service, 用于记录统计启动性能信息,读取/dev/bmetrics可以获取到这些信息 # use memorydump memorydump Sets the debug cookies, copies MMU info into reset_info asinfo, sets the secure monitor(TZ) dump buffer, starts tracelogger Usa…

【代码随想录算法训练营Day38】动态规划理论基础;509.斐波那契数;70.爬楼梯;746.使用最小花费爬楼梯

文章目录 ❇️Day 38 第九章 动态规划 part01✴️今日任务⏺️理论基础1. 什么是动态规划2. 动态规划题目类型3. 误区4. 动规五部曲5. 如何debug ❇️509. 斐波那契数随想录思路自己的代码 ❇️70. 爬楼梯随想录思路自己的代码 ❇️746. 使用最小花费爬楼梯随想录思路自己的代码…

Python与FPGA——全局二值化

文章目录 前言一、Python全局128二、Python全局均值三、Python全局OTSU四、FPGA全局128总结 前言 为什么要进行图像二值化,rgb图像有三个通道,处理图像的计算量较大,二值化的图像极大的减少了处理图像的计算量。即便从彩色图像转成了二值化图…

view的两种实现方式

想通过一个小功能的实现来表达我对编程的一些看法 一个多列表选择框,我第一种方案用了一个自定义view逻辑全写在一个类里,一个小时内很快就搞定了 但我也清楚,会有很大一些人如果看这个代码,会觉得很乱,甚至看不懂&…

linux系统---selinux

目录 前言 一、SELinux 的作用及权限管理机制 1.SELinux 的作用 1.1DAC 1.2MAC 1.3DAC 和 MAC 的对比 2.SELinux 基本概念 2.1主体(Subject) 2.2对象(Object) 2.3政策和规则(Policy & Rule) …

强化学习中动作价值函数和状态价值函数的联系区别?

在强化学习中,动作价值函数(Q函数)和状态价值函数(V函数)都是值函数,用于评估在不同状态或状态动作对下的值。它们之间存在联系,但有一些区别: 动作价值函数(Q函数&#…

Web自动化测试框架-PO模式

🔥 交流讨论:欢迎加入我们一起学习! 🔥 资源分享:耗时200小时精选的「软件测试」资料包 🔥 教程推荐:火遍全网的《软件测试》教程 📢欢迎点赞 👍 收藏 ⭐留言 &#x1…

Python接口自动化之cookie、session应用!

以下介绍cookie、session原理及在接口自动化中的应用。 HTTP 协议是一种无状态协议,即每次服务端接收到客户端的请求时,都是一个全新的请求,服务器并不知道客户端的历史请求记录;Session 和 Cookie 的主要目的就是为了弥补 HTTP 的…

L2-002 链表去重(Java)

给定一个带整数键值的链表 L,你需要把其中绝对值重复的键值结点删掉。即对每个键值 K,只有第一个绝对值等于 K 的结点被保留。同时,所有被删除的结点须被保存在另一个链表上。例如给定 L 为 21→-15→-15→-7→15,你需要输出去重后…

对列表的元素进行验证

摘要:开发中经常需要校验用户提交的值是否满足要求,Valid可用于方法参数、返回值等的验证,但是对于参数为列表时无效,此处记录几种对列表进行验证的方法 Valid 注解通常用于验证单个对象的字段,而不是整个列表。仅添加…

NetSuite Mass Update 批量更新功能

NetSuite中有一个小而精的便捷功能,但是也是一个很容易在实践中被大家遗忘的隐藏功能,就是Mass Update批量更新,在此想和各位分享一下~该功能主要是可以帮助用户快速将符合固定标准的记录中的单个/多个字段直接进行批量更新。如果…

快速批量将图片变成圆角怎么弄?教你一键将图片批量加圆角

在我们日常工作中,在设计图片的时候会要求将直角变成圆角,那么为什么要这么做呢?首先从圆角的设计语言上来说说,圆角看起来很现代,传达给人的感觉是温和友善的,被广泛的应用在产品中的图标、按钮等地方。而…

旷视IPC网络摄像机RTSP地址规则

主码流:rtsp://10.231.20.55/live?profileProfile_0000 子码流:rtsp://10.231.20.55/live?profileProfile_0001 三码流:rtsp://10.231.20.55/live?profileProfile_0002 带用户名密码格式,主码流:rtsp://admin:pw…

OJ习题之——圆括号编码

圆括号编码 1.题目描述2.完整代码3.图例演示 1.题目描述 题目描述 令Ss1 s2 …sn是一个规则的圆括号字符串。S以2种不同形式编码: (1)用一个整数序列Pp1 p2 … pn编码,pi代表在S中第i个右圆括号的左圆括号数量。(记为…

检测和处理异常之封装内建函数

​我们现在给出一个交互操作的例子 - 从最基本的错误检测开始, 然后逐步改进它, 增强代码的健壮性. 这里的问题是把一个用字符串表示的数值转换 为正确的数值表示形式, 而且在过程中要检测并处理可能的错误. float() 内建函数的基本作用是把任意一个数值类型转换为一个浮点数…

代码第二十四天-寻找旋转排序数组中的最小值Ⅱ

寻找旋转排序数组中的最小值Ⅱ 题目要求 解题思路 二分法 当遇到两个left、right两个位置值相同时候&#xff0c;可以选择将 right right-1 代码 class Solution:def findMin(self, nums: List[int]) -> int:left,right0,len(nums)-1while left<right:mid(leftright…

HarmonyOS—配置编译构建信息

在进行应用/服务的编译构建前&#xff0c;需要对工程和编译构建的Module进行设置。API Version 9、API Version 8与API Version 4~7的构建体系不同&#xff0c;因此在设置编译构建信息时也存在差异&#xff1a; API Version 9&#xff1a;需要对构建配置文件、构建脚本、应用依…