def visualization_result(final_embeddings_path, reverse_dictionary_path,
output_image, num_plot):
def plot_with_labels(low_dim_embs, labels, filename, fonts):
plt.figure(figsize=(18, 18)) # in inches
for i, label in enumerate(labels):
x, y = low_dim_embs[i, :]
plt.scatter(x, y, s=18)
plt.annotate(label,
fontproperties=fonts,
xy=(x, y),
xytext=(5, 2),
textcoords='offset points',
ha='right',
va='bottom')
plt.savefig(filename)
final_embeddings = yaml_utils.read(final_embeddings_path)
reverse_dictionary = yaml_utils.read(reverse_dictionary_path)
# 为了在图片上能显示出中文
font = FontProperties(fname=r"c:\windows\fonts\simsun.ttc", size=18)
tsne = TSNE(perplexity=30,
n_components=2,
init='pca',
n_iter=5000,
method='exact')
low_dim_embs = tsne.fit_transform(final_embeddings[:num_plot, :])
labels = [reverse_dictionary[i] for i in range(num_plot)]
plot_with_labels(low_dim_embs, labels, output_image, fonts=font)
def __init__(self, dataset_name, batch_size, valid_size, valid_window,
name, checkpoint_dir, embedding_size, num_sampled, num_epoch,
sess, tag, **args):
self.dataset_name = dataset_name
self.batch_size = batch_size
self.dataset_info = yaml_utils.read(args['dataset']['path'])
self.vocabulary_size = self.dataset_info['vocabulary_size']
self.reverse_dictionary = yaml_utils.read(
self.dataset_info['reverse_dictionary'])
self.train_data_generator = generate_batch(self.dataset_info['data'],
**args['dataset'])
# We pick a random validation set to sample nearest neighbors. Here we limit the
# validation samples to the words that have a low numeric ID, which by
# construction are also the most frequent.
self.valid_size = valid_size
self.valid_examples = np.array(
random.sample(range(valid_window), valid_size))
self.name = name
self.checkpoint_dir = Path(
checkpoint_dir) / self.dataset_name / self.name / tag
self.embedding_size = embedding_size
self.num_sampled = num_sampled
self.num_epoch = num_epoch
self.valid_freq = 10000
self.sess = sess
self.tag = tag
self.kwargs = args
self.build_network()
self.saver = tf.train.Saver()
def most_similar(final_embeddings_path, reverse_dictionary_path, words):
reverse_dictionary = yaml_utils.read(reverse_dictionary_path)
final_embeddings = yaml_utils.read(final_embeddings_path)
tf.set_random_seed(19)
tf_config = tf.ConfigProto(allow_soft_placement=True)
tf_config.gpu_options.allow_growth = True
with tf.Session(config=tf_config) as sess:
valid_dataset = tf.placeholder(tf.int32, shape=[5])
normalized_embeddings = tf.placeholder(tf.float32, shape=[5000, 128])
valid_embeddings = tf.nn.embedding_lookup(normalized_embeddings,
valid_dataset)
similarity = tf.matmul(valid_embeddings,
normalized_embeddings,
transpose_b=True)
init_op = tf.global_variables_initializer()
sess.run(init_op)
sim = sess.run(similarity,
feed_dict={
valid_dataset: words,
normalized_embeddings: final_embeddings
})
for i in range(len(words)):
valid_word = reverse_dictionary[words[i]]
top_k = 5
nearest = (-sim[i, :]).argsort()[1:top_k + 1]
log_str = '最接近 ' + valid_word + ' 的词语是:'
for k in range(top_k):
close_word = reverse_dictionary[nearest[k]]
log_str += str(k + 1) + ':' + close_word + ' '
print(log_str)
def data_loader():
train_list = yaml_utils.read(str(output_path / 't22seg_train.yaml'))
train_generator = data_generator(train_list, batch_size=6)
test_list = yaml_utils.read(str(output_path / 't22seg_test.yaml'))
test_generator = data_generator(test_list, batch_size=12)
return train_generator, len(train_list), test_generator, len(test_list)
def __init__(self, sess, option):
option = Option(option)
self.sess = sess
self.options = option
self.print_freq = option.print_freq
self.save_freq = option.save_freq
self.batch_size = option.batch_size
self.image_size = option.dataset.image_size
self.in_channels = option.model.in_channels
self.out_channels = option.model.out_channels
self.L1_lambda = option.model.l1_lambda
self.is_training = option.phase == 'train'
self.train_dir = yaml_utils.read(option.dataset.train_path)
self.test_dir = yaml_utils.read(option.dataset.test_path)
self.generator = unet
self.discriminator = patch_gan
self.criterionGAN = lsgan_loss
net_options = {
'batch_size': self.batch_size,
'image_size': self.image_size,
'out_channels': self.out_channels,
'G_channels': option.model.generator.channels,
'D_channels': option.model.discriminator.channels,
'is_training': self.is_training
}
self._build_model(net_options)
self.saver = tf.train.Saver()
def evaluate_model(args):
tf.set_random_seed(19)
tf_config = tf.ConfigProto(allow_soft_placement=True)
tf_config.gpu_options.allow_growth = True
with tf.Session(config=tf_config) as sess:
print('导入数据')
dataset_info = yaml_utils.read(args['dataset']['path'])
dictionary = yaml_utils.read(dataset_info['dictionary_path'])
print('导入数据字典完成')
reverse_dictionary = yaml_utils.read(
dataset_info['reverse_dictionary_path'])
print('导入反向字典完成')
if 'embedding_path' in dataset_info.keys():
embedding = np.array(yaml_utils.read(
dataset_info['embedding_path']),
dtype=np.float32)
else:
embedding = None
print('导入词向量完成')
test_dataset = yaml_utils.read(dataset_info['eval_path'])
print('导入测试数据完成')
print('导入完成')
data_loader = get_data_loader_by_name(
args['dataset']['data_generator'])
eval_data_generator = data_loader(
dictionary,
False,
test_dataset,
batch_size=args['batch_size'],
seq_length=args['dataset']['seq_length'],
reverse_dictionary=reverse_dictionary)
eval_data_generator.get_reverse_dictionary()
model_class = get_model_class_by_name(args['model']['name'])
model = model_class(sess=sess,
train_generator=None,
eval_generator=eval_data_generator,
embedding=embedding,
**dataset_info,
**args['dataset'],
**args['model'],
**args)
result, labels = model.test()
# yaml_utils.write(args['model']['checkpoint_dir'] + '/' + args['dataset']['dataset_name'] + '/' +
# args['model']['name'] + '/' + args['tag'] + '/' + 'best_result.yaml', result)
print('评估')
print(
metrics.classification_report(
labels, result, target_names=eval_data_generator.get_labels()))
print('混淆矩阵')
cm = metrics.confusion_matrix(labels, result)
print(cm)
def train(args):
tf.set_random_seed(19)
tf_config = tf.ConfigProto(allow_soft_placement=True)
tf_config.gpu_options.allow_growth = True
with tf.Session(config=tf_config) as sess:
print('导入数据')
dataset_info = yaml_utils.read(args['dataset']['path'])
dictionary = yaml_utils.read(dataset_info['dictionary_path'])
print('导入数据字典完成')
if 'embedding_path' in dataset_info.keys():
embedding = np.array(yaml_utils.read(
dataset_info['embedding_path']),
dtype=np.float32)
else:
embedding = None
# embedding = None # test without embedding
print('导入词向量完成')
train_dataset = yaml_utils.read(dataset_info['train_path'])
print('导入数据训练数据完成')
eval_dataset = yaml_utils.read(dataset_info['eval_path'])
print('导入数据验证数据完成')
print('导入完成')
data_loader = get_data_loader_by_name(
args['dataset']['data_generator'])
train_data_generator = data_loader(
dictionary,
True,
train_dataset,
batch_size=args['batch_size'],
seq_length=args['dataset']['seq_length'])
eval_data_generator = data_loader(
dictionary,
False,
eval_dataset,
batch_size=args['batch_size'],
seq_length=args['dataset']['seq_length'])
model_class = get_model_class_by_name(args['model']['name'])
model = model_class(sess=sess,
train_generator=train_data_generator,
eval_generator=eval_data_generator,
embedding=embedding,
**dataset_info,
**args['dataset'],
**args['model'],
**args)
model.train()
def generate_batch(data_path, batch_size, num_skips, skip_window, **args):
data = yaml_utils.read(data_path)
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)
buffer.extend(data[0:span])
data_index = span # init buffer and data_index
while True:
for i in range(batch_size // num_skips):
context_words = [w for w in range(span) if w != skip_window]
words_to_use = random.sample(context_words, num_skips)
for j, context_word in enumerate(words_to_use):
batch[i * num_skips + j] = buffer[skip_window]
labels[i * num_skips + j, 0] = buffer[context_word]
if data_index == len(data):
buffer.extend(data[0:span])
data_index = span
else:
buffer.append(data[data_index])
data_index = (data_index + 1) % len(data)
yield batch, labels
import cv2
import numpy as np
from pathlib import Path
from PIL import Image
from utils import yaml_utils
from yolo3.model import YOLO3
if __name__ == '__main__':
# dataset
image_path = './dataset/yolo3/football/img2.jpg'
data_shape = np.array((416, 416)) # multiple of 32, hw
dataset_name = 'coco2017'
anchors = np.array(yaml_utils.read('configs/yolo3/anchors.yaml'))
classes = yaml_utils.read('dataset/yolo3/{}/classes.yaml'.format(dataset_name))
num_layers = len(anchors) // 3 # Different detection scales y1,y2,y3
anchor_mask = [[6, 7, 8], [3, 4, 5], [0, 1, 2]]
# model
yolo3 = YOLO3(data_shape, classes, num_layers, anchor_mask, anchors, './_checkpoints/yolov3/')
yolo3.build_eval_model(dataset_name, score_threshold=0.3, iou_threshold=0.45)
image = cv2.imread(image_path)
image = Image.fromarray(image)
objects, _ = yolo3.detect_image(image)
image = np.array(image)
for obj in objects:
bounding_box = obj['bounding_box']
cv2.rectangle(image, (bounding_box[0], bounding_box[1]), (bounding_box[2], bounding_box[3]), (0, 0, 255),
thickness=2)
output_dir = Path('./_results') / dataset_name
output_dir.mkdir(exist_ok=True, parents=True)
buffer = collections.deque(maxlen=span)
buffer.extend(data[0:span])
data_index = span # init buffer and data_index
while True:
for i in range(batch_size // num_skips):
context_words = [w for w in range(span) if w != skip_window]
words_to_use = random.sample(context_words, num_skips)
for j, context_word in enumerate(words_to_use):
batch[i * num_skips + j] = buffer[skip_window]
labels[i * num_skips + j, 0] = buffer[context_word]
if data_index == len(data):
buffer.extend(data[0:span])
data_index = span
else:
buffer.append(data[data_index])
data_index = (data_index + 1) % len(data)
yield batch, labels
if __name__ == '__main__':
print('读取数据')
dataset = yaml_utils.read('dataset/little_data.yaml')
print('读取数据完毕')
data = dataset['data']
reverse_dictionary = dataset['reverse_dictionary']
generator = generate_batch(data, 8, 2, 1)
batch, labels = next(generator)
for i in range(8):
print(batch[i], reverse_dictionary[batch[i]], '->', labels[i, 0],
reverse_dictionary[labels[i, 0]])
import cv2
import numpy as np
import xml.etree.ElementTree as ET
from pathlib import Path
from utils import yaml_utils
train_scale = 0.99
classes = {'ball': 0, 'messi': 1}
data_dir = '/home/yf/dataset/football/'# E:/Dataset/football/
bounding_boxes = yaml_utils.read(data_dir + 'dataset.yaml')
output_dir = Path('../../dataset/yolo3/football/')
dataset = list()
for item in bounding_boxes:
image_path = data_dir + 'images/' + item['name'] + '.jpg'
image = cv2.imread(image_path)
image_shape = item['shape']
objects = list()
for _obj in item['bounding_box']:
bndbox = {'xmin': _obj['shape'][0], 'ymin': _obj['shape'][1], 'xmax': _obj['shape'][2],
'ymax': _obj['shape'][3]}
cv2.rectangle(image, (bndbox['xmin'], bndbox['ymin']), (bndbox['xmax'], bndbox['ymax']), (0, 0, 255),
thickness=2)
objects.append({'class_id': classes[_obj['name']], 'bndbox': bndbox})
dataset.append({'image_path': image_path, 'size': image_shape, 'objects': objects})
# cv2.imshow('image', image) # 展示图片
# cv2.waitKey(1)
output_dir.mkdir(parents=True, exist_ok=True)
np.random.shuffle(dataset)
train_steps = int(len(dataset) * train_scale)
# one-hot 处理
label_id = self.label_dictionary[source_label]
label = np.zeros((len(self.label_dictionary)), dtype=np.float32)
label[label_id] = 1.0
return input, label
def get_data_generator(self):
batch_input = list()
batch_label = list()
while True:
if self.is_augmented:
np.random.shuffle(self.dataset_list)
for item in self.dataset_list:
transf_input, transf_label = self.transform_word(item['input'], item['label'])
batch_input.append(transf_input)
batch_label.append(transf_label)
if len(batch_input) == self.batch_size:
yield np.array(batch_input), np.array(batch_label)
batch_input = list()
batch_label = list()
if __name__ == '__main__':
dataset_info = yaml_utils.read('../dataset/aclImdb/info.yaml')
dictionary = yaml_utils.read(dataset_info['dictionary_path'])
train_dataset = yaml_utils.read(dataset_info['eval_path'])
print('读取完毕')
data_generator = MultipleFileDataGenerator(dictionary, True, train_dataset, 32, 600)
batch_input, batch_label = next(data_generator.get_data_generator())
print(11)
batch_images.append(image)
for l in range(num_layers):
batch_labels[l].append(labels[l])
if len(batch_images) == batch_size:
batch_labels = [
np.array(batch_labels[l]) for l in range(num_layers)
]
yield [np.array(batch_images),
*batch_labels], np.zeros(batch_size)
batch_images = []
batch_labels = [list() for _ in range(num_layers)]
if __name__ == '__main__':
dataset_name = 'voc2012'
anchors = np.array(yaml_utils.read('../configs/yolo3/anchors.yaml'))
classes = yaml_utils.read(
'../dataset/yolo3/{}/classes.yaml'.format(dataset_name))
train_dataset = yaml_utils.read(
'../dataset/yolo3/{}/train_dataset.yaml'.format(dataset_name))
eval_dataset = yaml_utils.read(
'../dataset/yolo3/{}/eval_dataset.yaml'.format(dataset_name))
data_shape = np.array((416, 416)) # multiple of 32, hw
batch_size = 3
# dataset
train_generator = data_generator(train_dataset, batch_size, data_shape,
len(classes), anchors, True)
train_value = next(train_generator)
eval_generator = data_generator(eval_dataset, batch_size, data_shape,
len(classes), anchors, False)
def get_config(path):
_dict = yaml_utils.read(path)
return _dict
def get_config(name):
base_config = yaml_utils.read('configs/chinese.yaml')
config_ = dict_update(base_config,
yaml_utils.read('configs/' + name + '.yaml'))
return config_
def get_config(name):
config_ = yaml_utils.read('configs/' + name + '.yaml')
return config_
init_op = tf.global_variables_initializer()
sess.run(init_op)
sim = sess.run(similarity,
feed_dict={
valid_dataset: words,
normalized_embeddings: final_embeddings
})
for i in range(len(words)):
valid_word = reverse_dictionary[words[i]]
top_k = 5
nearest = (-sim[i, :]).argsort()[1:top_k + 1]
log_str = '最接近 ' + valid_word + ' 的词语是:'
for k in range(top_k):
close_word = reverse_dictionary[nearest[k]]
log_str += str(k + 1) + ':' + close_word + ' '
print(log_str)
if __name__ == '__main__':
dataset_name = 'text8'
model_name = 'SkipGram'
tag = 'base'
dataset_info = yaml_utils.read('dataset/' + dataset_name + '/info.yaml')
checkpoint_dir = './_checkpoint/' + dataset_name + '/' + model_name + '/' + tag + '/'
# visualization_result(checkpoint_dir + 'final_embeddings.yaml', dataset_info['reverse_dictionary'],
# checkpoint_dir + 'tsne.png', 100)
most_similar(checkpoint_dir + 'final_embeddings.yaml',
dataset_info['reverse_dictionary'], [1, 8, 34, 96, 144])
# 62, 77, 95, 155, 187 wiki_corpus