t2vec 辅助笔记：data_utils
1 argsort
'''
目的是对一个列表 seq 中的子列表或数组按其长度进行排序，并返回排序后的索引。
具体来说，它会按长度的降序排列，这意味着最长的子列表/数组的索引会在前面。
'''
def argsort(seq):
"""
sort by length in reverse order
---
seq (list[array[int32]])
"""
return [x for x,y in sorted(enumerate(seq),
key = lambda x: len(x[1]),
reverse=True)]- `enumerate(seq)` 返回一个枚举对象，其中包含 `seq` 中每个项的索引和值。
- `key = lambda x: len(x[1])` 是排序的关键。它告诉 `sorted` 函数按照长度 (`len(x[1])`) 进行排序。这里的 `x[1]` 表示 `enumerate` 枚举对象的值，即 `seq` 中的子列表/数组。
- `reverse=True` 指定排序应按降序进行。
- 最后，列表解析 `[x for x,y in ...]` 提取了排序后的索引值，这些索引值随后返回。
1.1 举例
seq = [[1, 2], [1, 2, 3, 4], [1], [1, 2, 3]]
result = argsort(seq)
print(result)
#[1, 3, 0, 2]2 pad_array相关
2.1 pad_array
'''
对给定的数组 a 进行填充，使其长度达到指定的 max_length。填充的值是 PAD
'''
def pad_array(a, max_length, PAD=constants.PAD):
"""
a (array[int32])
"""
return np.concatenate((a, [PAD]*(max_length - len(a))))- `[PAD]*(max_length - len(a))`：这部分代码会创建一个新的列表，其长度为 `(max_length - len(a))`，并且所有的元素都是 `PAD`
- `np.concatenate((a, ...))`：这将原始数组 `a` 和新生成的 `PAD` 值列表连接起来，从而产生一个新的、长度为 `max_length` 的数组。
2.2 pad_arrays
'''
接受一个数组的列表（或序列的序列）a，并确保所有这些数组都填充到与列表中最长的数组相同的长度
'''
def pad_arrays(a):
max_length = max(map(len, a))
#确定 a 中的所有数组中的最大长度
a = [pad_array(a[i], max_length) for i in range(len(a))]
#遍历 a 中的每个数组，然后使用先前定义的 pad_array 函数将每个数组填充到 max_length
a = np.stack(a).astype(np.int)
#将填充后的数组堆叠成一个二维数组，确保所有的值都是整数类型
return torch.LongTensor(a)2.3 pad_arrays_pair
处理源-目标（src-trg）序列对，使源/目标序列分别填充到相同的长度
def pad_arrays_pair(src, trg, keep_invp=False):
"""
输入：
src (list[array[int32]])：一个包含源序列的列表。
trg (list[array[int32]])：一个包含目标序列的列表。
keep_invp：一个布尔值，用来决定是否保留反向排列的信息。
输出：
src (seq_len1, batch)：填充后的源序列的张量，形状为 (序列长度, 批量大小)。
trg (seq_len2, batch)：填充后的目标序列的张量，形状为 (序列长度, 批量大小)。
lengths (1, batch)：一个张量，包含源序列的原始长度。
invp (batch,)：一个张量，包含反向排列的信息，只有在 keep_invp 为 True 时才返回。
"""
TD = namedtuple('TD', ['src', 'lengths', 'trg', 'invp'])
assert len(src) == len(trg), "source and target should have the same length"
#确保源序列和目标序列的长度是相同的。
idx = argsort(src)
src = list(np.array(src)[idx])
trg = list(np.array(trg)[idx])
'''
使用 `argsort` 函数来获取按长度降序排序后的序列的索引。
然后，使用这些索引来对 `src` 和 `trg` 进行重新排序。
'''
lengths = list(map(len, src))
lengths = torch.LongTensor(lengths)
#计算每个源序列的长度并将其转换为一个 PyTorch 张量。
src = pad_arrays(src)
trg = pad_arrays(trg)
#使用之前定义的 `pad_arrays` 函数来对 `src` 和 `trg` 中的每个序列进行填充。
#(batch,seq_len1) (batch,seq_len2)
if keep_invp == True:
invp = torch.LongTensor(invpermute(idx))
# (batch, seq_len) => (seq_len, batch)
return TD(src=src.t().contiguous(),
lengths=lengths.view(1, -1),
trg=trg.t().contiguous(),
invp=invp)
else:
# (batch, seq_len) => (seq_len, batch)
return TD(src=src.t().contiguous(),
lengths=lengths.view(1, -1),
trg=trg.t().contiguous(),
invp=[])
2.4 pad_arrays_keep_invp
'''
对输入的序列src进行填充，以便它们在批处理中具有相同的长度。
同时，它还保存并返回一个逆排列，这样你可以使用这个逆排列来恢复原始的顺序
'''
def pad_arrays_keep_invp(src):
"""
Input:
src (list[array[int32]])
---
Output:
src (seq_len, batch)
lengths (1, batch)
invp (batch,): inverse permutation, src.t()[invp] gets original order
"""
idx = argsort(src)
#对src中的序列按长度进行排序,返回一个排列索引
src = list(np.array(src)[idx])
#通过索引idx从src中提取排序后的序列
lengths = list(map(len, src))
lengths = torch.LongTensor(lengths)
#获取每个序列的长度
src = pad_arrays(src)
#序列进行填充，使所有序列具有相同的长度
invp = torch.LongTensor(invpermute(idx))
#获得idx的逆排列，之后可以使用这个逆排列来恢复原始的顺序
return src.t().contiguous(), lengths.view(1, -1), invp3 invpermute
'''
计算一个排列的逆排列
给定一个排列 p，它的逆排列是一个排列 invp，满足 invp[p[i]] = i 和 p[invp[i]] = i 对所有 i 成立
'''
def invpermute(p):
"""
inverse permutation
"""
p = np.asarray(p)
invp = np.empty_like(p)
for i in range(p.size):
invp[p[i]] = i
#对于每个 i，设置 invp 在 p[i] 的位置上的值为 i
return invp3.1 举例
p = [2, 0, 1]
invp = invpermute(p)
invp
#[1, 2, 0]
- invp的第p[0]个位置（第2个位置）值为0
- invp的第p[1]个位置（第0个位置）值为1
- invp的第p[2]个位置（第1个位置）值为2
4 random_subseq
'''
根据给定的 rate 从输入的数组 a 中随机丢弃一些元素，但始终保留首尾两个元素
'''
def random_subseq(a, rate):
idx = np.random.rand(len(a)) < rate
#生成一个与 a 同长度的随机数组，其值在 [0, 1) 之间。
#然后，该随机数组中小于 rate 的值被标记为 True，其他的被标记为 False
idx[0], idx[-1] = True, True
'''
无论先前的随机操作的结果如何，这行代码确保数组 idx 的首元素和尾元素始终为 True
这意味着在最终结果中，a 的首尾元素永远不会被丢弃
'''
return a[idx]5 DataLoader
5.1 init
class DataLoader():
"""
srcfile: source file name
trgfile: target file name
batch: batch size
validate: if validate = True return batch orderly otherwise return
batch randomly
"""
def __init__(self, srcfile, trgfile, mtafile, batch, bucketsize, validate=False):
self.srcfile = srcfile
self.trgfile = trgfile
self.mtafile = mtafile
$源、目标、元文件文件名
self.batch = batch
self.validate = validate
#如果为True，则按照顺序返回batch，否则随即返回
#self.bucketsize = [(30, 30), (30, 50), (50, 50), (50, 70), (70, 70)]
self.bucketsize = bucketsize5.1.1 桶策略
- 桶是一种策略，用于在序列长度可变的情况下处理数据。
- 例如，假设我们有不同长度的句子，我们可能不希望为每个句子单独创建一个批处理，因为这会非常低效。
- 桶策略是将句子放入一个接近它们长度的桶中，以尽量减少填充。
5.2 insert
'''
将一个源序列（s）、一个目标序列（t）和一个元数据序列（m）插入到适当的桶中
'''
def insert(self, s, t, m):
for i in range(len(self.bucketsize)):
#遍历每个桶的大小
if len(s) <= self.bucketsize[i][0] and len(t) <= self.bucketsize[i][1]:
#检查序列 s 和 t 的长度是否匹配当前桶的大小
self.srcdata[i].append(np.array(s, dtype=np.int32))
self.trgdata[i].append(np.array(t, dtype=np.int32))
self.mtadata[i].append(np.array(m, dtype=np.float32))
return 1
return 0
#如果循环结束后，数据没有被插入到任何桶中，则返回 0，表示数据没有被插入5.3 load
'''
从指定的源文件、目标文件和元数据文件中加载数据，并按照之前定义的桶大小进行组织
'''
def load(self, max_num_line=0):
self.srcdata = [[] for _ in range(len(self.bucketsize))]
self.trgdata = [[] for _ in range(len(self.bucketsize))]
self.mtadata = [[] for _ in range(len(self.bucketsize))]
#根据桶的数量为 self.srcdata, self.trgdata 和 self.mtadata 初始化空列表。
srcstream, trgstream, mtastream = open(self.srcfile, 'r'), open(self.trgfile, 'r'), open(self.mtafile, 'r')
#从源、目标和元数据文件中读取数据
num_line = 0
for (s, t, m) in zip(srcstream, trgstream, mtastream):
#每次读取srcstream, trgstream, mtastream的各一行
s = [int(x) for x in s.split()]
#源数据直接转为整数列表
t = [constants.BOS] + [int(x) for x in t.split()] + [constants.EOS]
#目标数据前后添加起始（BOS）和结束（EOS）标记
m = [float(x) for x in m.split()]
num_line += self.insert(s, t, m)
#使用 insert 方法将数据插入到适当的桶中
#如果插入成功，那么num_line加一
if num_line >= max_num_line and max_num_line > 0: break
#如果达到最大行数 max_num_line（如果设置了的话），则停止读取
if num_line % 500000 == 0:
print("Read line {}".format(num_line))
#每读取 500,000 行，打印一条消息表示进度
## 如果处于验证模式，合并所有桶:
if self.validate == True:
self.srcdata = np.array(merge(*self.srcdata))
self.trgdata = np.array(merge(*self.trgdata))
self.mtadata = np.array(merge(*self.mtadata))
self.start = 0
self.size = len(self.srcdata)
else:
#否则，将数据转为 NumPy 数组，并计算桶的分配比例:
self.srcdata = list(map(np.array, self.srcdata))
self.trgdata = list(map(np.array, self.trgdata))
self.mtadata = list(map(np.array, self.mtadata))
self.allocation = list(map(len, self.srcdata))
#计算每个桶中的数据量，并存储在 self.allocation 中。
self.p = np.array(self.allocation) / sum(self.allocation)
#计算每个桶的相对大小，并存储在 self.p 中。
srcstream.close(), trgstream.close(), mtastream.close()
#关闭源、目标和元数据文件的文件流。5.4 getbatch_one
'''
获取一个批次的数据
'''
def getbatch_one(self):
if self.validate == True:
#验证模式
src = self.srcdata[self.start:self.start+self.batch]
trg = self.trgdata[self.start:self.start+self.batch]
mta = self.mtadata[self.start:self.start+self.batch]
#从当前的start位置开始，连续选取batch大小的数据
self.start += self.batch
#更新start以便下一次获取批次时从新的位置开始。
if self.start >= self.size:
self.start = 0
#如果start加上batch的大小超过了数据的大小，那么start将被重置为0
#这意味着验证数据是循环的
return list(src), list(trg), list(mta)
#返回这个批次的源数据、目标数据和元数据
else:
## 非验证模式
sample = np.random.multinomial(1, self.p)
#使用多项分布从self.p中抽取一个样本，表示抽取哪一个桶。
#这里的self.p是一个数组，表示每个"bucket"被选中的概率
'''
如果self.p = [0.2, 0.5, 0.3]，那么返回的数组可能是[0, 1, 0]，表示第二个"bucket"被选中
'''
bucket = np.nonzero(sample)[0][0]
'''
np.nonzero(sample) 返回一个元组，其中包含了sample中所有非零元素的索引
因为sample中只有一个元素是1（即被选中的"bucket"），所以这个函数会返回一个只有一个元素的数组
[0][0] 提取这个数组的第一个元素，即被选中的"bucket"的索引
'''
idx = np.random.choice(len(self.srcdata[bucket]), self.batch)
#从所选"bucket"中随机选择batch大小的数据。
src = self.srcdata[bucket][idx]
trg = self.trgdata[bucket][idx]
mta = self.mtadata[bucket][idx]
return list(src), list(trg), list(mta)
#返回这个批次的源数据、目标数据和元数据。
5.4.1 选择桶的两行举例
import numpy as np
sample=np.random.multinomial(1, np.array([0.2,0.3,0.5]))
sample
#array([1, 0, 0])
bucket = np.nonzero(sample)
bucket
#(array([0]),)
bucket[0][0]
#05.5 getbatch_generative
'''
从数据加载器中获取一个批次的数据
'''
def getbatch_generative(self):
src, trg, _ = self.getbatch_one()
#调用getbatch_one函数，该函数返回一批数据。它返回三个值：源数据、目标数据和元数据
return pad_arrays_pair(src, trg, keep_invp=False)
'''
填充src和trg，使得他们分别是相同长度
返回值一个名为TD的namedtuple，其中包含填充和排序后的src和trg，以及源数据的长度
'''5.6 getbatch_discriminative_cross
'''
获取三个batch的数据，a、p和n[锚点（anchor）、正例（positive）和负例（negative）]
'''
def getbatch_discriminative_cross(self):
def distance(x, y):
return np.linalg.norm(x - y)
#定义了一个简单的欧几里得距离函数来计算两个向量之间的距离。
a_src, a_trg, a_mta = self.getbatch_one()
p_src, p_trg, p_mta = self.getbatch_one()
n_src, n_trg, n_mta = self.getbatch_one()
'''
连续三次调用getbatch_one方法，获取三个不同的批次数据：a、p和n
代表了锚点（anchor）、正例（positive）和负例（negative）。
'''
for i in range(len(a_src)):
if distance(a_mta[i], p_mta[i]) > distance(a_mta[i], n_mta[i]):
p_src[i], n_src[i] = n_src[i], p_src[i]
p_trg[i], n_trg[i] = n_trg[i], p_trg[i]
p_mta[i], n_mta[i] = n_mta[i], p_mta[i]
'''
如果a和p之间的距离大于a和n之间的距离，我们交换p和n。
这是为了确保p是与a更接近的点，而n是更远离的点
'''
a = pad_arrays_pair(a_src, a_trg, keep_invp=True)
p = pad_arrays_pair(p_src, p_trg, keep_invp=True)
n = pad_arrays_pair(n_src, n_trg, keep_invp=True)
'''
对于每个数据批次，调用pad_arrays_pair进行填充和排序。
这里保持了逆排列信息，因为在后续的处理中需要它
'''
return a, p, n5.7 getbatch_discriminative_inner
'''
从给定的输入数据中生成a(锚点)、p(正例)、和n(负例)的批次，类似于上一个函数。
但在这里，所有这些批次数据都是从同一个初始数据的不同部分产生的。
'''
def getbatch_discriminative_inner(self):
a_src, a_trg = [], []
p_src, p_trg = [], []
n_src, n_trg = [], []
_, trgs, _ = self.getbatch_one()
#从getbatch_one方法中仅获取一个batch的目标数据trgs
#回忆：getbatch_one返回的东西还没有pad
for i in range(len(trgs)):
trg = trgs[i][1:-1]
#目标轨迹掐头去尾（BOS、EOS）
if len(trg) < 10: continue
#如果目标轨迹长度小于10，那么不考虑这条轨迹
a1, a3, a5 = 0, len(trg)//2, len(trg)
a2, a4 = (a1 + a3)//2, (a3 + a5)//2
#将trg数据(不考虑开头和结尾)分为三部分：a1到a5
'''
根据一个随机的rate，使用random_subseq函数来从这三部分中随机选取子序列
'''
rate = np.random.choice([0.5, 0.6, 0.8])
if np.random.rand() > 0.5:
a_src.append(random_subseq(trg[a1:a4], rate))
a_trg.append(np.r_[constants.BOS, trg[a1:a4], constants.EOS])
p_src.append(random_subseq(trg[a2:a5], rate))
p_trg.append(np.r_[constants.BOS, trg[a2:a5], constants.EOS])
n_src.append(random_subseq(trg[a3:a5], rate))
n_trg.append(np.r_[constants.BOS, trg[a3:a5], constants.EOS])
'''
如果np.random.rand() > 0.5，那么：
取a1到a4为锚点、a2到a5为正例、a3到a5为负例
'''
else:
a_src.append(random_subseq(trg[a2:a5], rate))
a_trg.append(np.r_[constants.BOS, trg[a2:a5], constants.EOS])
p_src.append(random_subseq(trg[a1:a4], rate))
p_trg.append(np.r_[constants.BOS, trg[a1:a4], constants.EOS])
n_src.append(random_subseq(trg[a1:a3], rate))
n_trg.append(np.r_[constants.BOS, trg[a1:a3], constants.EOS])
a = pad_arrays_pair(a_src, a_trg, keep_invp=True)
p = pad_arrays_pair(p_src, p_trg, keep_invp=True)
n = pad_arrays_pair(n_src, n_trg, keep_invp=True)
'''
使用pad_arrays_pair函数，我们将a_src, a_trg, p_src, p_trg, n_src, 和n_trg填充并排序
'''
return a, p, n6 DataOrderScaner
'''
从一个源文件中扫描和加载数据，并以批量方式返回这些数据
'''
class DataOrderScaner():
def __init__(self, srcfile, batch):
self.srcfile = srcfile
self.batch = batch
self.srcdata = []
self.start = 0
# 初始化函数，设置源文件、批处理大小，并初始化存放数据的列表
'''
从指定的源文件self.srcfile中加载数据，并将其存储到self.srcdata列表中
'''
def load(self, max_num_line=0):
num_line = 0
with open(self.srcfile, 'r') as srcstream:
for s in srcstream:
s = [int(x) for x in s.split()]
self.srcdata.append(np.array(s, dtype=np.int32))
#从指定的源文件self.srcfile中加载数据，并将其存储到self.srcdata列表中
num_line += 1
if max_num_line > 0 and num_line >= max_num_line:
break
self.size = len(self.srcdata)
self.start = 0
'''
从加载的数据中按批次获取数据，并进行适当的格式化处理
'''
def getbatch(self):
"""
Output:
src (seq_len, batch)
lengths (1, batch)
invp (batch,): inverse permutation, src.t()[invp] gets original order
"""
if self.start >= self.size:
return None, None, None
'''
首先，检查self.start（当前批次的开始位置）是否已经超过或等于self.size（总的数据大小）。
如果是这样，表示所有数据都已经被提取过了，所以直接返回None
'''
src = self.srcdata[self.start:self.start+self.batch]
#从self.srcdata中提取当前批次的数据
=
self.start += self.batch
return pad_arrays_keep_invp(src)
#对当前批次的数据进行处理，以获得适当的格式和反向排列