Question

我是机器学习的初学者，并且试图理解Udacity深度文本模型课程（作业5）。我没有得到关于跳过图算法的训练数据集在不同迭代中会有所不同的部分。

我试图重新编写自己的代码，但是我不知道如何使每次训练迭代的训练数据都不同。因此，每次我进行培训时，它都将以相同的单词进行培训，而不是覆盖整个词汇表。

这是Udacity生成训练数据集的原始代码：

data_index = 0

def generate_batch(batch_size, num_skips, skip_window):
global data_index
  assert batch_size % num_skips == 0
  assert num_skips <= 2 * skip_window
  batch = np.ndarray(shape=(batch_size), dtype=np.int32)
  labels = np.ndarray(shape=(batch_size, 1), dtype=np.int32)
  span = 2 * skip_window + 1 # [ skip_window target skip_window ]
  buffer = collections.deque(maxlen=span)
  for _ in range(span):
    buffer.append(data[data_index])
    data_index = (data_index + 1) % len(data)
  for i in range(batch_size // num_skips):
    target = skip_window  # target label at the center of the buffer
    targets_to_avoid = [ skip_window ]
    for j in range(num_skips):
      while target in targets_to_avoid:
        target = random.randint(0, span - 1)
      targets_to_avoid.append(target)
      batch[i * num_skips + j] = buffer[skip_window]
      labels[i * num_skips + j, 0] = buffer[target]
    buffer.append(data[data_index])
    data_index = (data_index + 1) % len(data)
  return batch, labels

这是我用于生成训练数据集的代码，我试图复制udacity编写的内容：

skip_window = 1
num_skips = 2
batch_size = 8
span = skip_window*2+1
assert num_skips <= skip_window*2

def generate_batch(batch_size,num_skips,skip_window):

    batch=[]
    label=[]
    target = skip_window

    for i in range(batch_size//num_skips):
        for j in range(num_skips):
            batch.append(data[target])
        for j in range(target-skip_window, target+skip_window+1):
            if j!= target:
                label.append([data[j]])
        target+=1

    batch=np.array(batch)
    label=np.array(label)
    return batch, label

这是训练代码中调用函数generate_batch的开始部分：

num_steps = 10001
print('valid examples: ', valid_examples)

with tf.Session(graph=graph) as session:
  tf.global_variables_initializer().run()
  print('Initialized')
  average_loss = 0
  for step in range(num_steps):
    batch_data, batch_labels = generate_batch(
      batch_size, num_skips, skip_window)
    print('batch ', step, ': ', batch_data)

当我使用Udacity代码运行训练时，它将为不同的步骤生成不同的数据：

batch  0 :  [   59    59   156   156   128   128   742   742   477   477 10572 10572
       134   134     1     1 27350 27350     2     2     1     1   103   103
       855   855     3     3     1     1 15068 15068     0     0     2     2
         1     1   151   151   855   855  3581  3581     1     1   195   195
        11    11   191   191    59    59     5     5     6     6 10713 10713
       215   215     7     7  1325  1325   105   105   455   455    20    20
        59    59  2732  2732   363   363     7     7  3673  3673     1     1
       709   709     2     2   372   372    27    27    41    41    37    37
        54    54   540   540    98    98    12    12     6     6  1424  1424
      2758  2758    19    19   568   568   687   687  7089  7089     1     1
       248   248  5234  5234    11    11  1053  1053]

batch  1 :  [  249   249 44612 44612  2878  2878   793   793   187   187  5234  5234
    12    12     6     6   201   201   603   603    11    11     1     1
  1135  1135    20    20  2622  2622    26    26  8984  8984     3     3
   280   280    32    32  4148  4148   142   142    60    60    26    26
  6438  6438  4187  4187     2     2   154   154    33    33   363   363
  5234  5234    37    37  1138  1138     7     7   448   448   345   345
  1819  1819    20    20  4861  4861     1     1  6754  6754     2     2
  7574  7574  1775  1775   567   567     1     1    94    94     1     1
   248   248 11065 11065    12    12    52    52  7089  7089    90    90
    27    27   271   271    38    38  5949  5949  4862  4862 20300 20300
    29    29     0     0    42    42   318   318]

我不知道如何修改我的代码，以便能够为每个批次生成不同的训练集，从而像大胆所做的一样。

非常感谢您！

构造用于跳过图算法的训练数据集（针对文本课程的Udacity深度模型课程分配5）

0 个答案: