Spaces:
Running
Running
File size: 5,236 Bytes
0b8359d |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 |
# Copyright 2017 The TensorFlow Authors All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Random helper functions for converting between indices and one-hot encodings
as well as printing/logging helpers.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
from six.moves import xrange
import tensorflow as tf
def variable_summaries(var, name):
"""Attach a lot of summaries to a Tensor."""
mean = tf.reduce_mean(var)
tf.summary.scalar('mean/' + name, mean)
with tf.name_scope('stddev'):
stddev = tf.sqrt(tf.reduce_sum(tf.square(var - mean)))
tf.summary.scalar('sttdev/' + name, stddev)
tf.summary.scalar('max/' + name, tf.reduce_max(var))
tf.summary.scalar('min/' + name, tf.reduce_min(var))
tf.summary.histogram(name, var)
def zip_seq_pred_crossent(id_to_word, sequences, predictions, cross_entropy):
"""Zip together the sequences, predictions, cross entropy."""
indices = convert_to_indices(sequences)
batch_of_metrics = []
for ind_batch, pred_batch, crossent_batch in zip(indices, predictions,
cross_entropy):
metrics = []
for index, pred, crossent in zip(ind_batch, pred_batch, crossent_batch):
metrics.append([str(id_to_word[index]), pred, crossent])
batch_of_metrics.append(metrics)
return batch_of_metrics
def print_and_log(log, id_to_word, sequence_eval, max_num_to_print=5):
"""Helper function for printing and logging evaluated sequences."""
indices_eval = convert_to_indices(sequence_eval)
indices_arr = np.asarray(indices_eval)
samples = convert_to_human_readable(id_to_word, indices_arr, max_num_to_print)
for i, sample in enumerate(samples):
print('Sample', i, '. ', sample)
log.write('\nSample ' + str(i) + '. ' + sample)
log.write('\n')
print('\n')
log.flush()
def convert_to_human_readable(id_to_word, arr, max_num_to_print):
"""Convert a np.array of indices into words using id_to_word dictionary.
Return max_num_to_print results.
"""
assert arr.ndim == 2
samples = []
for sequence_id in xrange(min(len(arr), max_num_to_print)):
buffer_str = ' '.join(
[str(id_to_word[index]) for index in arr[sequence_id, :]])
samples.append(buffer_str)
return samples
def index_to_vocab_array(indices, vocab_size, sequence_length):
"""Convert the indices into an array with vocab_size one-hot encoding."""
# Extract properties of the indices.
num_batches = len(indices)
shape = list(indices.shape)
shape.append(vocab_size)
# Construct the vocab_size array.
new_arr = np.zeros(shape)
for n in xrange(num_batches):
indices_batch = indices[n]
new_arr_batch = new_arr[n]
# We map all indices greater than the vocabulary size to an unknown
# character.
indices_batch = np.where(indices_batch < vocab_size, indices_batch,
vocab_size - 1)
# Convert indices to vocab_size dimensions.
new_arr_batch[np.arange(sequence_length), indices_batch] = 1
return new_arr
def convert_to_indices(sequences):
"""Convert a list of size [batch_size, sequence_length, vocab_size] to
a list of size [batch_size, sequence_length] where the vocab element is
denoted by the index.
"""
batch_of_indices = []
for sequence in sequences:
indices = []
for embedding in sequence:
indices.append(np.argmax(embedding))
batch_of_indices.append(indices)
return batch_of_indices
def convert_and_zip(id_to_word, sequences, predictions):
"""Helper function for printing or logging. Retrieves list of sequences
and predictions and zips them together.
"""
indices = convert_to_indices(sequences)
batch_of_indices_predictions = []
for index_batch, pred_batch in zip(indices, predictions):
indices_predictions = []
for index, pred in zip(index_batch, pred_batch):
indices_predictions.append([str(id_to_word[index]), pred])
batch_of_indices_predictions.append(indices_predictions)
return batch_of_indices_predictions
def recursive_length(item):
"""Recursively determine the total number of elements in nested list."""
if type(item) == list:
return sum(recursive_length(subitem) for subitem in item)
else:
return 1.
def percent_correct(real_sequence, fake_sequences):
"""Determine the percent of tokens correctly generated within a batch."""
identical = 0.
for fake_sequence in fake_sequences:
for real, fake in zip(real_sequence, fake_sequence):
if real == fake:
identical += 1.
return identical / recursive_length(fake_sequences)
|