def __init__(self, env, params):
self.env = env
params.actions = env.actions()
self.num_actions = env.actions()
self.episodes = params.episodes
self.steps = params.steps
self.train_steps = params.train_steps
self.update_freq = params.update_freq
self.save_weights = params.save_weights
self.history_length = params.history_length
self.discount = params.discount
self.eps = params.init_eps
self.eps_delta = (params.init_eps - params.final_eps) / params.final_eps_frame
self.replay_start_size = params.replay_start_size
self.eps_endt = params.final_eps_frame
self.random_starts = params.random_starts
self.batch_size = params.batch_size
self.ckpt_file = params.ckpt_dir+'/'+params.game
self.global_step = tf.Variable(0, trainable=False)
if params.lr_anneal:
self.lr = tf.train.exponential_decay(params.lr, self.global_step, params.lr_anneal, 0.96, staircase=True)
else:
self.lr = params.lr
self.buffer = Buffer(params)
self.memory = Memory(params.size, self.batch_size)
with tf.variable_scope("train") as self.train_scope:
self.train_net = ConvNet(params, trainable=True)
with tf.variable_scope("target") as self.target_scope:
self.target_net = ConvNet(params, trainable=False)
self.optimizer = tf.train.RMSPropOptimizer(self.lr, params.decay_rate, 0.0, self.eps)
self.actions = tf.placeholder(tf.float32, [None, self.num_actions])
self.q_target = tf.placeholder(tf.float32, [None])
self.q_train = tf.reduce_max(tf.mul(self.train_net.y, self.actions), reduction_indices=1)
self.diff = tf.sub(self.q_target, self.q_train)
half = tf.constant(0.5)
if params.clip_delta > 0:
abs_diff = tf.abs(self.diff)
clipped_diff = tf.clip_by_value(abs_diff, 0, 1)
linear_part = abs_diff - clipped_diff
quadratic_part = tf.square(clipped_diff)
self.diff_square = tf.mul(half, tf.add(quadratic_part, linear_part))
else:
self.diff_square = tf.mul(half, tf.square(self.diff))
if params.accumulator == 'sum':
self.loss = tf.reduce_sum(self.diff_square)
else:
self.loss = tf.reduce_mean(self.diff_square)
# backprop with RMS loss
self.task = self.optimizer.minimize(self.loss, global_step=self.global_step)
def run_experiment(algo, average_gradients, batch_size, iterations, verbose):
batch_size = batch_size
tf.reset_default_graph()
net = ConvNet()
validation_batch = mnist.test.images
val_count = validation_batch.shape[0]
validation_batch = np.reshape(validation_batch, (val_count, 28, 28, 1))
validation_labels = mnist.test.labels
net.setup_train(algo, average_gradients=average_gradients)
training_log = []
listloss = []
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for i in range(iterations):
batch = mnist.train.next_batch(batch_size)
input_batch = np.reshape(batch[0], (batch_size, 28, 28, 1))
loss = net.train(sess, input_batch, batch[1])
listloss.append(loss)
if (i + 1) % 100 == 0:
accuracy = net.evaluate(sess, validation_batch,
validation_labels)
training_log.append((accuracy, i + 1))
if verbose:
print('[{:d}/{:d}] loss: {:.3g}, accuracy: {:.3g}%'.format(
i + 1, iterations, loss, accuracy))
accuracy = net.evaluate(sess, validation_batch, validation_labels)
training_log.append((accuracy, iterations))
best = sorted(training_log, key=lambda x: x[0], reverse=True)[0]
print('Training finished. Best accuracy: {:.3g} at iteration {:d}.'.
format(best[0], best[1]))
return listloss
def main():
jsonResponse = json.loads(request.data.decode('utf-8'))
image = jsonResponse['image']
png_recovered = base64.decodestring(image.split(',')[1])
f = open("temp.png","w")
f.write(png_recovered)
f.close()
tab = cv2.bitwise_not(cv2.imread("temp.png",0))
new = cv2.resize (tab, (imsize,imsize))
cv2.imwrite("visu.png",new)
json_file = open('model.json','r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
loaded_model.load_weights("model.h5")
reseau = ConvNet(imsize,imsize)
reseau.model = loaded_model
response = flask.jsonify({
'number': reseau.prediction(new),
'image': jsonResponse['image']
})
K.clear_session()
return response
def encoder_convnet(input_shape, dimH, dimZ, dimY, n_channel, dropout, name):
# encoder for z (low res)
layer_channels = [n_channel for i in range(3)]
filter_width = 5
filter_shapes = construct_filter_shapes(layer_channels, filter_width)
fc_layer_sizes = [dimH]
enc_conv, conv_output_shape = ConvNet(name+'_conv', input_shape, filter_shapes, \
fc_layer_sizes, 'relu',
last_activation = 'relu',
dropout = dropout)
print('encoder shared Conv net ' + ' network architecture:', \
conv_output_shape, fc_layer_sizes)
fc_layer = [dimH + dimY, dimH, dimZ]
enc_mlp = []
for i in range(len(fc_layer) - 1):
if i + 2 < len(fc_layer):
activation = 'relu'
else:
activation = 'linear'
name_layer = name + '_mlp_l%d' % i
enc_mlp.append(
mlp_layer(fc_layer[i], fc_layer[i + 1], activation, name_layer))
def apply_conv(x):
return enc_conv(x)
def apply_mlp(x, y):
out = tf.concat([x, y], 1)
for layer in enc_mlp:
out = layer(out)
return out
return apply_conv, apply_mlp
def construct_model(input_shape, dimZ, dimF, dimH, batch_norm=False):
# test dropout model to start with
# construct encoder
weight_init = 'glorot_normal'
layer_channels = [32, 64, 64]
filter_width = 3
filter_shapes = construct_filter_shapes(layer_channels, filter_width)
fc_layer_sizes = [dimH, dimF]
enc, conv_output_shape = ConvNet('encoder_conv', input_shape, filter_shapes, fc_layer_sizes, \
'relu', batch_norm, last_activation = 'relu', \
dropout = False)
print 'encoder' + ' network architecture:', \
conv_output_shape, fc_layer_sizes
# construct the decoder
batch_size_ph = tf.placeholder(tf.int32, shape=(), name='batch_size_ph')
dec = DeConvNet(input_shape,
dimH,
dimF,
last_activation='sigmoid',
name='decoder')
# construct the generator
generator = DeConvNet(input_shape,
dimH,
dimF,
last_activation='sigmoid',
name='generator')
def gen(z):
N = z.get_shape().as_list()[0]
x = generator(z)
return tf.reshape(x, (N, ) + input_shape)
return enc, dec, gen, batch_size_ph
def make_model(cfg):
if cfg['model_name'] in convnet_names:
return ConvNet(cfg)
elif cfg['model_name'] == 'dndf':
return DNDF(cfg)
else:
raise NotImplementedError
def main():
net = ConvNet()
net.cuda()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) #SGD with momentum
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
# load snapshot
snapshot = torch.load('./convnet_CIFAR10_snapshot/snapshot2_12000')
net.load_state_dict(snapshot['state_dict'])
optimizer.load_state_dict(snapshot['optimizer'])
data_loader = load_data('./CIFAR10_data')
image_num = random.randint(0,len(data_loader.dataset)-1)
img = np.transpose(data_loader.dataset[image_num][0].numpy(2,0,1))
img = np.rot90(img,k=3)
img = img / 2 + 0.5 # unnormalize
print(classes[data_loader.dataset[image_num][1]])
plt.imshow(img)
plt.title('image: %d, %s' % (image_num, str(classes[data_loader.dataset[image_num][1]])))
plt.axis('off')
# plt.show()
img_size = data_loader.dataset[image_num][0].size()
input = torch.FloatTensor(1, img_size[0], img_size[1],img_size[2]).zero_()
input[0,:] = data_loader.dataset[image_num][0]
output = net(Variable(input.cuda()))
print(output)
_, predicted = torch.max(output.data, 1)
print('Predicted: %s' % classes[predicted[0][0]]) # remind that the input has a 4D dimension (batch, channel, width, height)
def generate_model(model_name):
if model_name == 'conv_net':
return ConvNet()
if model_name == 'conv_dropout_net':
return ConvDropoutNet()
# if model_name == 'conv_drop_batch_norm_net':
# return ConvDropBatchNormNet()
raise Exception()
def main(settings):
convnet = ConvNet(settings)
train = ConvNetTrain(convnet, settings)
train.train()
model_path = settings['model_path']
train.save_model(model_path)
summary = train.summary()
print(summary)
summary.to_csv("{}_summary.csv".format(os.path.splitext(model_path)[0]))
def making_diagnosis(convnet_settings,
img_path,
score_thresh=0.97,
infection_threshold=5,
inflammation_threshold=5,
highlight=False):
print(img_path)
img = cv2.imread(img_path)
# select blood cells
detector = BloodCellDetector('', '')
detector.img = img
detector.find_cells()
# print("Found {} blood cell".format(len(detector.cells_images)))
# classify the founded blood cells
convnet = ConvNet(convnet_settings)
convnet.load_model(convnet_settings['model_path'])
lymph_count = 0
neutr_count = 0
total_count = 0
for cell_img in tqdm(detector.cells_images, ncols=100):
total_count += 1
prediction, scores = convnet.predict(cell_img, with_scores=True)
if max(scores) >= score_thresh:
if prediction == 1:
lymph_count += 1
elif prediction == 2:
neutr_count += 1
print("{} lymphocytes and {} neutrophils were found among {} blood cells".
format(lymph_count, neutr_count, total_count))
# making diagnosis
if neutr_count > infection_threshold:
diagnosis = 'infection'
elif lymph_count > inflammation_threshold:
diagnosis = 'inflammation'
else:
diagnosis = 'bening'
if highlight:
visualizer = BloodCellVisualizer(detector, convnet)
result_img = visualizer.highlight_cells(
img,
labels=['1-lymphocytes', '2-neutrophils'],
show_scores=False,
make_zoom=True)
output_path = '{}_diagnosis_{}{}'.format(
os.path.splitext(img_path)[0], diagnosis,
os.path.splitext(img_path)[1])
cv2.imwrite(output_path, result_img)
print('File "{}" was created.'.format(output_path))
return neutr_count, diagnosis
def generator(input_shape, dimH, dimZ, dimY, n_channel, last_activation, name):
# first construct p(y|z)
fc_layers = [dimZ, dimH, dimY]
pyz_mlp_layers = []
N_layers = len(fc_layers) - 1
l = 0
for i in range(N_layers):
name_layer = name + '_pyz_mlp_l%d' % l
if i + 1 == N_layers:
activation = 'linear'
else:
activation = 'relu'
pyz_mlp_layers.append(
mlp_layer(fc_layers[i], fc_layers[i + 1], activation, name_layer))
def pyz_params(z):
out = z
for layer in pyz_mlp_layers:
out = layer(out)
return out
# now construct p(z|x)
# encoder for z (low res)
layer_channels = [n_channel for i in range(3)]
filter_width = 5
filter_shapes = construct_filter_shapes(layer_channels, filter_width)
fc_layer_sizes = [dimH]
gen_conv2, conv_output_shape = ConvNet(name+'_pzx_conv', input_shape, filter_shapes, \
fc_layer_sizes, 'relu',
last_activation = 'relu')
print('generator shared Conv net ' + ' network architecture:', \
conv_output_shape, fc_layer_sizes)
fc_layers = [dimH, dimH, dimZ * 2]
pzx_mlp_layers = []
N_layers = len(fc_layers) - 1
l = 0
for i in range(N_layers):
name_layer = name + '_pzx_mlp_l%d' % l
if i + 1 == N_layers:
activation = 'linear'
else:
activation = 'relu'
pzx_mlp_layers.append(
mlp_layer(fc_layers[i], fc_layers[i + 1], activation, name_layer))
def pzx_params(x):
out = gen_conv2(x)
for layer in pzx_mlp_layers:
out = layer(out)
mu, log_sig = tf.split(out, 2, axis=1)
return mu, log_sig
return pyz_params, pzx_params
def main(settings):
convnet = ConvNet(settings)
train = ConvNetTrain(convnet, settings)
# for num in tqdm(range(1, 11)):
for num in range(10, 11):
ratio = num / 10
train.train(ratio=ratio)
model_path = settings['model_path'] + '_{}'.format(int(ratio*100))
train.save_model(model_path)
summary = train.summary()
print(summary)
summary.to_csv("{}_summary.csv".format(os.path.splitext(model_path)[0]))
def make_diagnosis(self, convnet_settings):
start_time = time.time()
print(
'\033[94m* making diagnosis is in progress. Please wait...\033[0m')
image_diagnoses = []
for img_name in os.listdir(os.path.join(self.work_dir, 'images')):
if not img_name.startswith('.'):
diagnosis = making_diagnosis(
convnet_settings,
os.path.join(self.work_dir, 'images', img_name))
image_diagnoses.append((img_name, diagnosis))
detector = BloodCellDetector('', '')
convnet = ConvNet(convnet_settings)
convnet.load_model(convnet_settings['model_path'])
visualizer = BloodCellVisualizer(detector, convnet)
image_diagnoses.sort(key=lambda x: x[1][0])
image_diagnoses = image_diagnoses[::-1]
cnt = 0
for img_info in image_diagnoses[:self.top]:
if img_info[1][1] == 'infection':
img = cv2.imread(
os.path.join(self.work_dir, 'images', img_info[0]))
result_img = visualizer.highlight_cells(
img,
labels=['1-lymphocytes', '2-neutrophils'],
show_scores=False,
make_zoom=False)
cv2.imwrite(
os.path.join(self.work_dir, 'marked' + img_info[0]),
result_img)
cnt += 1
print(
'\033[92m* {} with selected neutrophil images are created in the "{}"\033[0m'
.format(cnt, self.work_dir))
print('\033[92m* making diagnosis was completed in {:.2f} (s)\033[0m'.
format(time.time() - start_time))
diagnoses = [d[1][1] for d in image_diagnoses]
if 'infection' in diagnoses:
total_diagnosis = 'infection'
elif 'inflammation' in diagnoses:
total_diagnosis = 'inflammation'
else:
total_diagnosis = 'bening'
return image_diagnoses, total_diagnosis
def __init__(self, feat_extract_name , n_processes, low_pass, high_pass, gauss_noise, roi, size_percentage,\
feature_extractor__shape_norm, feature_extractor__shape_conv, \
feature_extractor__shape_pool, feature_extractor__n_filters, \
feature_extractor__stride_pool, feature_extractor__stoc_pool, \
feature_extractor__div_norm, feature_extractor__region_shape, \
feature_extractor__region_stride, feature_extractor__top_regions, \
feature_extractor__stride_pool_recurrent, feature_extractor__analysis_shape, \
feature_extractor__method, \
feature_extractor__n_tiles, augmentation, multi_column, aug_rotate \
):
self.low_pass = low_pass
self.high_pass = high_pass
self.gauss_noise = gauss_noise
self.roi = roi
self.size_percentage = size_percentage
self.augmentation = augmentation
self.aug_rotate = aug_rotate
self.multi_column = multi_column
self.feat_extract_name = feat_extract_name
self.n_processes = n_processes
if feat_extract_name.lower() == 'convnet':
self.feature_extractor = eval(feat_extract_name + '()')
self.feature_extractor.n_filters = feature_extractor__n_filters
self.feature_extractor.shape_norm = feature_extractor__shape_norm
self.feature_extractor.shape_conv = feature_extractor__shape_conv
self.feature_extractor.shape_pool = feature_extractor__shape_pool
self.feature_extractor.stride_pool = feature_extractor__stride_pool
self.feature_extractor.div_norm = feature_extractor__div_norm
self.feature_extractor.stoc_pool = feature_extractor__stoc_pool
elif feat_extract_name.lower() == 'mrrconvnet':
self.feature_extractor = eval(feat_extract_name + '()')
convnet = ConvNet()
convnet.n_filters = feature_extractor__n_filters
convnet.shape_norm = feature_extractor__shape_norm
convnet.shape_conv = feature_extractor__shape_conv
convnet.shape_pool = feature_extractor__shape_pool
convnet.stride_pool = feature_extractor__stride_pool
convnet.div_norm = feature_extractor__div_norm
convnet.stoc_pool = feature_extractor__stoc_pool
self.feature_extractor.convnet = convnet
self.feature_extractor.region_shape = feature_extractor__region_shape
self.feature_extractor.region_stride = feature_extractor__region_stride
self.feature_extractor.top_regions = feature_extractor__top_regions
self.feature_extractor.stride_pool_recurrent = feature_extractor__stride_pool_recurrent
self.feature_extractor.analysis_shape = feature_extractor__analysis_shape
elif feat_extract_name.lower() == 'lbp':
self.feature_extractor = eval(feat_extract_name + '()')
self.feature_extractor.method = feature_extractor__method
self.feature_extractor.n_tiles = feature_extractor__n_tiles
def build_image_embedding(self):
print('\tBuild image embedding')
with tf.variable_scope('ConvNet') as scope:
convnet = ConvNet(self.config, self.mode)
cnn_output = convnet.build_model(self.images)
with tf.variable_scope('IcestateEmbedding') as scope:
image_embeddings = tf.contrib.layers.fully_connected(
inputs=cnn_output,
num_outputs=self.config.feature_dims,
activation_fn=None,
weights_initializer=self.initializer,
biases_initializer=None,
scope=scope)
tf.constant(self.config.embedding_size, name="embedding_size")
self.image_embeddings = image_embeddings
def training(settings):
print('Training Model')
for (num_epochs, learning_rate) in settings:
mnist = get_data()
eval_mnist = get_data()
x_train = np.reshape(mnist.train.images, [-1, 1, 28, 28])
y_train = mnist.train.labels
x_test = np.reshape(mnist.test.images, [-1, 1, 28, 28])
y_test = mnist.test.labels
test_accuracy, train_accuracy = ConvNet(x_train, y_train, x_test,
y_test, num_epochs, batch_size,
learning_rate,
log_period_samples)
experiments_list.append(
((num_epochs, learning_rate), train_accuracy, test_accuracy))
print(experiments_list)
def fit(data, filter_sizes, out_channels, strides, paddings,
smooth_weights, sparse_weights, readout_sparse_weight,
learning_rate=0.001, max_iter=10000, val_steps=50,
early_stopping_steps=10):
'''Fit CNN model.
Parameters:
data: Dataset object (see load_data())
filter_sizes: Filter sizes (list containing one number per conv layer)
out_channels: Number of output channels (list; one number per conv layer)
strides: Strides (list; one number per conv layer)
paddings: Paddings (list; one number per conv layer; VALID|SAME)
smooth_weights: Weights for smoothness regularizer (list; one number per conv layer)
sparse_weights: Weights for group sparsity regularizer (list; one number per conv layer)
readout_sparse_weight: Sparisty of readout weights (scalar)
learning_rate: Learning rate (default: 0.001)
max_iter: Max. number of iterations (default: 10000)
val_steps: Validation interval (number of iterations; default: 50)
early_stopping_steps: Tolerance for early stopping. Will stop optimizing
after this number of validation steps without decrease of loss.
Output:
cnn: A fitted ConvNet object
'''
cnn = ConvNet(data, log_dir='cnn', log_hash='manual')
cnn.build(filter_sizes=filter_sizes,
out_channels=out_channels,
strides=strides,
paddings=paddings,
smooth_weights=smooth_weights,
sparse_weights=sparse_weights,
readout_sparse_weight=readout_sparse_weight)
for lr_decay in range(3):
training = cnn.train(max_iter=max_iter,
val_steps=val_steps,
early_stopping_steps=early_stopping_steps,
learning_rate=learning_rate)
for (i, (logl, readout_sparse, conv_sparse, smooth, total_loss, pred)) in training:
print('Step %d | Loss: %.2f | Poisson: %.2f | L1 readout: %.2f | Sparse: %.2f | Smooth: %.2f | Var(y): %.3f' % \
(i, total_loss, logl, readout_sparse, conv_sparse, smooth, np.mean(np.var(pred, axis=0))))
learning_rate /= 3
print('Reducing learning rate to %f' % learning_rate)
print('Done fitting')
return cnn
def main(_):
config = Config()
print "Initializing Convolutional Neural Network...\n"
cnn = ConvNet(256,256)
print "Initializing Image Segmentation Model...\n"
model = ImageSegmentation(config, cnn)
print "Retrieving data from pipeline...\n"
data = create_data_pipeline()
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
print "Beginning to train model\n"
train_loss = model.train(sess, data, 'train_dir', 2)
print "Finished"
def find_pathology(self, convnet_settings):
detection = ConvNet(convnet_settings)
detection.load_model(convnet_settings['model_path'])
pathology_images = []
for img_name in tqdm(os.listdir(self.imgs_directory), ncols=80):
if '.jpeg' not in img_name:
continue
img = cv2.imread(os.path.join(self.imgs_directory, img_name))
img = misc.imresize(arr=img, size=(detection.img_size, detection.img_size, 3))
img_arr = np.asarray([img])
prediction = detection.model.predict(img_arr)[0][0]
if int(prediction) == 0:
pathology_images.append((img_name, prediction))
pathology_images = np.asarray(pathology_images)
pathology_images = pathology_images[pathology_images[:, 1].argsort()]
pathology_images = pathology_images[::-1]
pathology_images = [img_name for img_name, _ in pathology_images]
return pathology_images[:self.top]
def train_proc(network, **kwargs):
log_path = os.path.join(save_dir, network.checkpoint_name() + '.log')
real_stdout = sys.stdout
sys.stdout = open(log_path, 'w')
convnet = None
try:
from convnet import ConvNet
np.random.seed(network.seed)
op, load_dic = network.get_op(**kwargs)
convnet = ConvNet(op, load_dic)
convnet.train()
return True
except RuntimeError:
print(traceback.format_exc())
if convnet:
print("\nerrored at epoch %d" % (convnet.epoch))
except:
print(traceback.format_exc())
finally:
if convnet:
convnet.destroy_model_lib()
reset_std('out', real_stdout)
def main():
# Training settings
parser = argparse.ArgumentParser(
description='Obtain confidence scores from trained networks')
parser.add_argument('--test-batch-size',
type=int,
default=200,
metavar='N',
help='input batch size for testing (default: 200)')
parser.add_argument('--no-cuda',
action='store_true',
default=False,
help='disables CUDA training')
parser.add_argument('--seed',
type=int,
default=1,
metavar='S',
help='random seed (default: 1)')
parser.add_argument('--arch',
type=str,
default='wrn',
metavar='ARC',
help='neural network arch')
parser.add_argument('--data',
type=str,
default='cifar10',
metavar='DT',
help='dataset the classifier was trained with')
parser.add_argument('--test-data',
type=str,
default='fakedata',
metavar='DT',
help='dataset used to test the classifier')
parser.add_argument('--lsun-path', type=str, help='path to LSUN dataset')
parser.add_argument('--save_path',
type=str,
default='data',
metavar='SP',
help='path to save the produced confidence')
parser.add_argument('--print-time',
type=bool,
default=False,
metavar='PT',
help='print elapsed time per batch')
parser.add_argument(
'--mode',
type=str,
default='msp',
metavar='M',
help=
'available modes: msp (maximum softmax probability), tmsp (t-softmax msp), tmsp0.5, tmsp5, tmsp10 (where number indicates nu value) odin. default: msp'
)
parser.add_argument('--T',
type=float,
default=1000.0,
metavar='T',
help='ODIN temperature scaling')
parser.add_argument('--eps',
type=float,
default=0.001,
metavar='EPS',
help='ODIN epsilon value')
args = parser.parse_args()
use_cuda = not args.no_cuda and torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
torch.manual_seed(args.seed)
np.random.seed(args.seed)
if device.type == 'cuda':
torch.cuda.manual_seed(args.seed)
kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}
mean, std = get_normal(args.data)
if args.test_data == "cifar10":
test_transform = trn.Compose(
[trn.ToTensor(), trn.Normalize(mean, std)])
test_loader = torch.utils.data.DataLoader(
datasets.CIFAR10('../data',
download=True,
train=False,
transform=test_transform),
batch_size=args.test_batch_size,
shuffle=True,
**kwargs)
elif args.test_data == "cifar10_bw":
test_transform = trn.Compose([
trn.Grayscale(),
trn.Resize((28, 28)),
trn.ToTensor(),
trn.Normalize(mean, std)
])
test_loader = torch.utils.data.DataLoader(
datasets.CIFAR10('../data',
download=True,
train=False,
transform=test_transform),
batch_size=args.test_batch_size,
shuffle=True,
**kwargs)
elif args.test_data == "svhn":
test_transform = trn.Compose(
[trn.ToTensor(), trn.Normalize(mean, std)])
test_loader = torch.utils.data.DataLoader(
datasets.SVHN('../data',
download=True,
split='test',
transform=test_transform),
batch_size=args.test_batch_size,
shuffle=True,
**kwargs)
elif args.test_data == "fakedata":
test_transform = trn.Compose(
[trn.ToTensor(), trn.Normalize(mean, std)])
test_loader = torch.utils.data.DataLoader(
datasets.FakeData(size=10000,
image_size=(3, 32, 32),
transform=test_transform),
batch_size=args.test_batch_size,
shuffle=True,
**kwargs)
elif args.test_data == "fakedata_bw":
test_transform = trn.Compose(
[trn.ToTensor(), trn.Normalize(mean, std)])
test_loader = torch.utils.data.DataLoader(
datasets.FakeData(size=10000,
image_size=(1, 28, 28),
transform=test_transform),
batch_size=args.test_batch_size,
shuffle=True,
**kwargs)
elif args.test_data == "fakedata_wm":
# wrong mean normalization
mean = (50, 50, 50)
test_transform = trn.Compose(
[trn.ToTensor(), trn.Normalize(mean, std)])
test_loader = torch.utils.data.DataLoader(
datasets.FakeData(size=10000,
image_size=(3, 32, 32),
transform=test_transform),
batch_size=args.test_batch_size,
shuffle=True,
**kwargs)
elif args.test_data == "fmnist":
test_transform = trn.Compose(
[trn.ToTensor(), trn.Normalize(mean, std)])
test_loader = torch.utils.data.DataLoader(
datasets.FashionMNIST('../data',
download=True,
train=False,
transform=test_transform),
batch_size=args.test_batch_size,
shuffle=True,
**kwargs)
elif args.test_data == "kmnist":
test_transform = trn.Compose(
[trn.ToTensor(), trn.Normalize(mean, std)])
test_loader = torch.utils.data.DataLoader(
datasets.KMNIST('../data',
download=True,
train=False,
transform=test_transform),
batch_size=args.test_batch_size,
shuffle=True,
**kwargs)
elif args.test_data == "mnist":
test_transform = trn.Compose([
trn.ToTensor(),
# lambda x : x.repeat(3,1,1) * torch.rand(3,1,1),
trn.Normalize(mean, std)
])
test_loader = torch.utils.data.DataLoader(
datasets.MNIST('../data',
download=True,
train=False,
transform=test_transform),
batch_size=args.test_batch_size,
shuffle=True,
**kwargs)
elif args.test_data == "lsun":
test_transform = trn.Compose([
trn.Resize((32, 32)), #trn.CenterCrop(32),
trn.ToTensor(),
trn.Normalize(mean, std)
])
test_loader = torch.utils.data.DataLoader(
datasets.LSUN(args.lsun_path,
classes='test',
transform=test_transform),
batch_size=args.test_batch_size,
shuffle=True,
**kwargs)
if args.data == "cifar10":
Nc = 10
channels = 3
elif args.data == "svhn":
Nc = 10
channels = 3
elif args.data == "fmnist":
Nc = 10
channels = 1
elif args.data == "kmnist":
Nc = 10
channels = 1
if (args.mode == 'msp') | (args.mode == 'odin') | (args.mode == 'cb'):
nu = 0.0
elif args.mode == 'tmsp':
nu = 1.0
elif args.mode == 'tmsp0.5':
nu = 0.5
elif args.mode == 'tmsp5.0':
nu = 5.0
elif args.mode == 'tmsp10.0':
nu = 10.0
else:
print('mode not recognized!')
quit()
model_path = 'models'
model_path += '/' + args.data
model_name = args.arch + 'nu{}'.format(nu)
if args.arch == 'densenet':
densenet_depth = 100
model = DenseNet(densenet_depth, Nc, nu=nu).to(device)
elif args.arch == 'densenet_small':
densenet_depth = 10
model = DenseNet(densenet_depth, Nc, nu=nu).to(device)
elif args.arch == 'convnet':
model = ConvNet(Nc, channels=channels, nu=nu).to(device)
model.load_state_dict(
torch.load(model_path + '/' + model_name + '.pt', map_location=device))
score, is_hit = test(args, model, device, test_loader)
if not os.path.exists(args.save_path):
os.makedirs(args.save_path)
df = pd.DataFrame(data={'score': score, 'is_hit': is_hit})
df.to_csv('{}/{}_train{}_test{}_{}.csv'.format(args.save_path, args.arch,
args.data, args.test_data,
args.mode))
return dropout, reg
cifar10 = cifar10_utils.get_cifar10('./cifar10/cifar-10-batches-py')
print('done getting cifar10')
image_shape = cifar10.train.images.shape[1:4]
num_classes = cifar10.test.labels.shape[1]
# Construct linear convnet graph
x = tf.placeholder(tf.float32, shape=[None] + list(image_shape), name='x')
y = tf.placeholder(tf.int32, shape=(None, num_classes), name='y')
is_training = tf.placeholder(dtype=tf.bool, shape=(), name='isTraining')
model = ConvNet(is_training=is_training)
_ = model.inference(x)
#%%
with tf.Session() as sess:
# Initialise all variables
tf.initialize_all_variables().run(session=sess)
checkpoint_dirs = ['checkpoints_0reg_lr1e4_sqrtinit']
ckpt_file = 'epoch14000.ckpt'
#subdir = './'
subdir = 'checkpoints_new/'
test_size = 1000
saver = tf.train.Saver()
""" View the options used to create a checkpoint
python view_options.py --load-file <checkpoint>
"""
from convnet import ConvNet
from python_util.gpumodel import IGPUModel
op = ConvNet.get_options_parser()
op, load_dic = IGPUModel.parse_options(op)
model = ConvNet(op, load_dic)
model.op.print_values()
print "========================="
model.print_model_state()
visdom_log['train_loss'].append(loss_train)
visdom_log['test_loss'].append(loss_test)
return plot, visdom_log
if __name__ == "__main__":
logs = []
colors = []
trace_names = []
start_t = time.time()
print("\n\n > Teacher training ... ")
colors.append('orange')
trace_names.extend(['Teacher Train', 'Teacher Test'])
model = ConvNet(net_dataset=CIFAR10)
model.cuda()
plot, log_base = run_training(model, 'Teacher_', args.epochs)
logs.append(log_base)
# wider student training
print("\n\n > Wider Student training ... ")
colors.append('blue')
trace_names.extend(['Wider Net2Net Train', 'Wider Net2Net Test'])
model_ = ConvNet(net_dataset=CIFAR10)
model_ = copy.deepcopy(model)
del model
model = model_
model.wider(operation='net2net', widening_factor=2)
print model
def objective(layer_file_name, param_file_name, save_file_name):
def logprob_errors(error_output):
error_types, n = error_output
logprob = error_types['logprob'][0] / n
classifier = error_types['logprob'][1] / n
logprob = np.inf if np.isnan(logprob) else logprob
classifier = np.inf if np.isnan(classifier) else classifier
return logprob, classifier
real_stdout = sys.stdout
sys.stdout = open(save_file_name + '.log', 'w')
convnet = None
try:
# set up options
op = ConvNet.get_options_parser()
for option in op.get_options_list():
option.set_default()
op.set_value('data_path', os.path.expanduser('~/data/cifar-10-py-colmajor/'))
op.set_value('dp_type', 'cifar')
op.set_value('inner_size', '24')
op.set_value('gpu', '0')
op.set_value('testing_freq', '25')
op.set_value('train_batch_range', '1-5')
op.set_value('test_batch_range', '6')
op.set_value('num_epochs', n_epochs, parse=False)
op.set_value('layer_def', layer_file_name)
op.set_value('layer_params', param_file_name)
op.set_value('save_file_override', save_file_name)
convnet = ConvNet(op, None)
# train for three epochs and make sure error is okay
convnet.num_epochs = 3
convnet.train()
logprob, error = logprob_errors(convnet.train_outputs[-1])
if not (error > 0 and error < 0.85):
# should get at most 85% error after three epochs
print "\naborted (%s, %s)" % (logprob, error)
return logprob, error
# train for full epochs
convnet.num_epochs = n_epochs
convnet.train()
logprob, error = logprob_errors(convnet.get_test_error())
print "\nfinished (%s, %s)" % (logprob, error)
return logprob, error
except RuntimeError:
print "\nerrored at epoch %d" % (convnet.epoch)
return np.inf, 1.0
finally:
if convnet is not None:
convnet.destroy_model_lib()
print "\n" # end any pending lines to ensure flush
sys.stdout.flush()
sys.stdout.close()
sys.stdout = real_stdout
train_csvs = csvs[:train_csvs_size]
valid_csvs = csvs[train_csvs_size:]
n_train = count_datasets_total(train_csvs)
n_valid = count_datasets_total(valid_csvs)
print(f'# of training set: {n_train}')
print(f'# of validation set: {n_valid}')
word_encoder, countrycode_encoder = get_encoders(csvs)
with tf.Session() as sess:
K.set_session(sess)
convnet = ConvNet(
word_encoder,
countrycode_encoder,
)
model = convnet.get_model()
model.summary()
hist = model.fit_generator(
convnet.get_generator(
train_csvs,
batch_size=BATCH_SIZE,
),
steps_per_epoch=np.ceil(n_train / BATCH_SIZE).astype('int'),
epochs=EPOCHS,
validation_data=convnet.get_generator(
valid_csvs,
batch_size=BATCH_SIZE,
),
valid_target_y = './yval.txt'
data = DataSet(pos_samples, neg_samples, vocab_file, inv_vocab_file,
valid_target_x, valid_target_y)
with tf.Graph().as_default():
session_conf = tf.ConfigProto(
allow_soft_placement=FLAGS.allow_soft_placement,
log_device_placement=FLAGS.log_device_placement)
sess = tf.Session(config=session_conf)
with sess.as_default():
cnn = ConvNet(
seq_lenth=data.seq_len,
num_classes=2,
vocab_size=len(data.vocab),
embedding_dim=FLAGS.embedding_dim,
filter_lengths=[int(l) for l in FLAGS.filter_lengths.split(',')],
num_filters=FLAGS.num_filters)
global_step = tf.Variable(0, name='global_step', trainable=False)
optimizer = tf.train.AdamOptimizer(1e-3)
grads_and_vars = optimizer.compute_gradients(cnn.loss)
train_op = optimizer.apply_gradients(grads_and_vars,
global_step=global_step)
sess.run(tf.initialize_all_variables())
def train_step(x_batch, y_batch):
feed_dict = {
cnn.input_x: x_batch,
def generator(input_shape, dimH, dimZ, dimY, n_channel, last_activation, name):
# first construct p(y|z, x)
# encoder for z (low res)
layer_channels = [n_channel, n_channel * 2, n_channel * 4]
filter_width = 5
filter_shapes = construct_filter_shapes(layer_channels, filter_width)
fc_layer_sizes = [dimH]
gen_conv, conv_output_shape = ConvNet(name+'_pyzx_conv', input_shape, filter_shapes, \
fc_layer_sizes, 'relu',
last_activation = 'relu')
print('generator shared Conv net ' + ' network architecture:', \
conv_output_shape, fc_layer_sizes)
fc_layers = [dimZ + dimH, dimH, dimY]
pyzx_mlp_layers = []
N_layers = len(fc_layers) - 1
l = 0
for i in range(N_layers):
name_layer = name + '_pyzx_mlp_l%d' % l
if i + 1 == N_layers:
activation = 'linear'
else:
activation = 'relu'
pyzx_mlp_layers.append(
mlp_layer(fc_layers[i], fc_layers[i + 1], activation, name_layer))
def pyzx_params(z, x):
fea = gen_conv(x)
out = tf.concat([fea, z], axis=1)
for layer in pyzx_mlp_layers:
out = layer(out)
return out
# now construct p(x|z)
filter_width = 5
decoder_input_shape = [(4, 4, n_channel * 4), (8, 8, n_channel * 2),
(16, 16, n_channel)]
decoder_input_shape.append(input_shape)
fc_layers = [dimZ, dimH, int(np.prod(decoder_input_shape[0]))]
l = 0
# first include the MLP
mlp_layers = []
N_layers = len(fc_layers) - 1
for i in range(N_layers):
name_layer = name + '_l%d' % l
mlp_layers.append(
mlp_layer(fc_layers[i], fc_layers[i + 1], 'relu', name_layer))
l += 1
conv_layers = []
N_layers = len(decoder_input_shape) - 1
for i in range(N_layers):
if i < N_layers - 1:
activation = 'relu'
else:
activation = last_activation
name_layer = name + '_l%d' % l
output_shape = decoder_input_shape[i + 1]
input_shape = decoder_input_shape[i]
up_height = int(np.ceil(output_shape[0] / float(input_shape[0])))
up_width = int(np.ceil(output_shape[1] / float(input_shape[1])))
strides = (1, up_height, up_width, 1)
if activation in [
'logistic_cdf', 'gaussian'
] and i == N_layers - 1: # ugly wrapping for logistic cdf likelihoods
activation = 'split'
output_shape = (output_shape[0], output_shape[1],
output_shape[2] * 2)
filter_shape = (filter_width, filter_width, output_shape[-1],
input_shape[-1])
conv_layers.append(deconv_layer(output_shape, filter_shape, activation, \
strides, name_layer))
l += 1
print('decoder shared Conv Net of size', decoder_input_shape)
def pxz_params(z):
x = z
for layer in mlp_layers:
x = layer(x)
x = tf.reshape(x,
(x.get_shape().as_list()[0], ) + decoder_input_shape[0])
for layer in conv_layers:
x = layer(x)
return x
return pyzx_params, pxz_params
from convnet import ConvNet
import tqdm
import os
import json
import cv2
path = '/Users/ayder/enviroments/pnenv/src/convnet/data/new_data/test'
err_path = '/Users/ayder/enviroments/pnenv/src/convnet/data/new_data/errors'
settings = json.load(open('/Users/ayder/enviroments/pnenv/src/convnet/settings/settings.json'))
print(settings)
settings['model_path'] = '/Users/ayder/enviroments/pnenv/src/convnet/models/model_is50_ep50_bs20'
convnet = ConvNet(settings)
convnet.load_model(settings['model_path'])
wrong_samples = {}
sample_cnt = 0
err_cnt = 0
for lbl in settings['labels']:
lbl_path = os.path.join(path, lbl)
files = [f for f in os.listdir(lbl_path) if not f.startswith('.')]
wrong_samples[lbl] = []
for f in tqdm.tqdm(files):
sample_cnt += 1
img = cv2.imread(os.path.join(lbl_path, f))
prediction = convnet.predict(img)
prediction_label = convnet.labels[prediction]
if prediction_label != lbl:
wrong_samples[lbl].append((f, prediction_label))
prot = args.protocol.split('-')
data_path_train, data_path_val = set_protocol(args.data_path, prot[0], prot[1])
trainset = OpenMIC_Data('train', data_path_train)
train_sampler = CategoriesSampler(trainset.label, 100,
args.train_way, args.shot + args.query)
train_loader = DataLoader(dataset=trainset, batch_sampler=train_sampler,
num_workers=8, pin_memory=True)
valset = OpenMIC_Data('val', data_path_val)
val_sampler = CategoriesSampler(valset.label, 1000,
args.test_way, args.shot + args.query)
val_loader = DataLoader(dataset=valset, batch_sampler=val_sampler,
num_workers=8, pin_memory=True)
model = ConvNet().cuda()
shot_num = args.shot
if args.shot == 1:
shot_num = 2
args.subspace_dim = 1
else:
shot_num = args.shot
projection_pro = Subspace_Projection(num_dim=args.subspace_dim)
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.5)
def save_model(name):
if not os.path.exists(args.save_path):
os.mkdir(args.save_path)
