def main(): if not os.path.exists(a.output_dir): os.makedirs(a.output_dir) input = tf.placeholder(tf.string, shape=[1]) key = tf.placeholder(tf.string, shape=[1]) in_data = tf.decode_base64(input[0]) img = tf.image.decode_png(in_data) img = tf.image.rgb_to_grayscale(img) out_data = tf.image.encode_png(img) output = tf.convert_to_tensor([tf.encode_base64(out_data)]) variable_to_allow_model_saving = tf.Variable(1, dtype=tf.float32) inputs = { "key": key.name, "input": input.name } tf.add_to_collection("inputs", json.dumps(inputs)) outputs = { "key": tf.identity(key).name, "output": output.name, } tf.add_to_collection("outputs", json.dumps(outputs)) init_op = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init_op) saver = tf.train.Saver() saver.export_meta_graph(filename=os.path.join(a.output_dir, "export.meta")) saver.save(sess, os.path.join(a.output_dir, "export"), write_meta_graph=False) print("exported example model to %s" % a.output_dir)
def _decode_jpg(image): img_buf = BytesIO() Image.new('RGB', (16, 16)).save(img_buf, 'jpeg') default_image_string = base64.urlsafe_b64encode(img_buf.getvalue()) image = tf.where(tf.equal(image, ''), default_image_string, image) image = tf.decode_base64(image) image = tf.image.decode_jpeg(image, channels=3) image = tf.reshape(image, [-1]) image = tf.reduce_max(image) return image
def _decode_and_resize(image_str_tensor): """Decodes jpeg string, resizes it and returns a uint8 tensor.""" # These constants are set by Inception v3's expectations. height = 299 width = 299 channels = 3 image = tf.where(tf.equal(image_str_tensor, ''), IMAGE_DEFAULT_STRING, image_str_tensor) image = tf.decode_base64(image) image = tf.image.decode_jpeg(image, channels=channels) image = tf.expand_dims(image, 0) image = tf.image.resize_bilinear(image, [height, width], align_corners=False) image = tf.squeeze(image, squeeze_dims=[0]) image = tf.cast(image, dtype=tf.uint8) return image
def export_model(): # export the generator to a meta graph that can be imported later for standalone generation if args.lab_colorization: raise Exception("export not supported for lab_colorization") input = tf.placeholder(tf.string, shape=[1]) input_data = tf.decode_base64(input[0]) input_image = tf.image.decode_png(input_data) # remove alpha channel if present input_image = tf.cond(tf.equal(tf.shape(input_image)[2], 4), lambda: input_image[:, :, :3], lambda: input_image) # convert grayscale to RGB input_image = tf.cond(tf.equal(tf.shape(input_image)[2], 1), lambda: tf.image.grayscale_to_rgb(input_image), lambda: input_image) input_image = tf.image.convert_image_dtype(input_image, dtype=tf.float32) input_image.set_shape([CROP_SIZE, CROP_SIZE, 3]) batch_input = tf.expand_dims(input_image, axis=0) with tf.variable_scope("generator"): batch_output = deprocess(create_generator(preprocess(batch_input), 3)) output_image = tf.image.convert_image_dtype(batch_output, dtype=tf.uint8)[0] if args.output_filetype == "png": output_data = tf.image.encode_png(output_image) elif args.output_filetype == "jpeg": output_data = tf.image.encode_jpeg(output_image, quality=80) else: raise Exception("invalid filetype") output = tf.convert_to_tensor([tf.encode_base64(output_data)]) key = tf.placeholder(tf.string, shape=[1]) inputs = { "key": key.name, "input": input.name } tf.add_to_collection("inputs", json.dumps(inputs)) outputs = { "key": tf.identity(key).name, "output": output.name, } tf.add_to_collection("outputs", json.dumps(outputs)) init_op = tf.global_variables_initializer() restore_saver = tf.train.Saver() export_saver = tf.train.Saver() with tf.Session() as sess: sess.run(init_op) print("loading model from checkpoint") checkpoint = tf.train.latest_checkpoint(args.checkpoint) restore_saver.restore(sess, checkpoint) print("exporting model") export_saver.export_meta_graph(filename=os.path.join(args.output_dir, "export.meta")) export_saver.save(sess, os.path.join(args.output_dir, "export"), write_meta_graph=False)
def handle(): image_data = tf.decode_base64(request.data) array = tf.image.decode_jpeg(image_data, channels=3) # array = tf.Print(array, [array], message="Print: ") # array.eval(session=sess) # b = tf.add(array, array).eval(session=sess) resized = tf.image.resize_images([array], [64, 64]) # resized = tf.Print(resized, [resized], message="Print: ") # resized.eval(session=sess) # c = tf.add(resized, resized).eval(session=sess) return match(resized)
def main(): mnist = input_data.read_data_sets("./input_data") x = tf.placeholder(tf.float32, [None, 784]) logits = inference(x) y_ = tf.placeholder(tf.int64, [None]) cross_entropy = tf.losses.sparse_softmax_cross_entropy(labels=y_, logits=logits) train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy) init_op = tf.global_variables_initializer() # Define op for model signature tf.get_variable_scope().reuse_variables() model_base64_placeholder = tf.placeholder(shape=[None], dtype=tf.string, name="model_input_b64_images") model_base64_string = tf.decode_base64(model_base64_placeholder) model_base64_input = tf.map_fn(lambda x: tf.image.resize_images( tf.image.decode_jpeg(x, channels=1), [28, 28]), model_base64_string, dtype=tf.float32) model_base64_reshape_input = tf.reshape(model_base64_input, [-1, 28 * 28]) model_logits = inference(model_base64_reshape_input) model_predict_softmax = tf.nn.softmax(model_logits) model_predict = tf.argmax(model_predict_softmax, 1) with tf.Session() as sess: sess.run(init_op) for i in range(938): batch_xs, batch_ys = mnist.train.next_batch(64) sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys}) # Export image model export_dir = "./model/1" print("Try to export the model in {}".format(export_dir)) tf.saved_model.simple_save(sess, export_dir, inputs={"images": model_base64_placeholder}, outputs={ "predict": model_predict, "probability": model_predict_softmax })
def _decode_and_resize(image_str_tensor): """Decodes jpeg string, resizes it and returns a uint8 tensor.""" # These constants are set by Inception v3's expectations. height = 299 width = 299 channels = 3 image = tf.where(tf.equal(image_str_tensor, ''), IMAGE_DEFAULT_STRING, image_str_tensor) image = tf.decode_base64(image) image = tf.image.decode_jpeg(image, channels=channels) image = tf.expand_dims(image, 0) image = tf.image.resize_bilinear(image, [height, width], align_corners=False) image = tf.squeeze(image, squeeze_dims=[0]) image = tf.cast(image, dtype=tf.uint8) return image
def read_tensor_from_imageb64(img_b64, input_height=224, input_width=224, input_mean=128, input_std=128): image_reader = tf.image.decode_jpeg(tf.decode_base64(img_b64), channels=3, name="jpeg_reader") float_caster = tf.cast(image_reader, tf.float32) dims_expander = tf.expand_dims(float_caster, 0) resized = tf.image.resize_bilinear(dims_expander, [input_height, input_width]) normalized = tf.divide(tf.subtract(resized, [input_mean]), [input_std]) sess = tf.Session() result = sess.run(normalized) return result
def parsing_fn(self, example_proto): """tf.data.Dataset parsing function.""" # Parse parsed_features = self.raw_parsing_fn(example_proto) # Reshape parsed_features['image'] = decode_raw_image(parsed_features['image'], (32, 32, 3), image_size=self.image_size) parsed_features['image'] = tf.identity(parsed_features['image'], name='image') parsed_features['class'] = tf.to_int32(parsed_features['class']) parsed_features['coarse_class'] = tf.to_int32( parsed_features['coarse_class']) parsed_features['coarse_class_str'] = tf.decode_base64( parsed_features['coarse_class_str']) # Return if self.verbose: print_records(parsed_features) return parsed_features
def parsing_fn(self, example_proto): """tf.data.Dataset parsing function.""" # Parse parsed_features = self.raw_parsing_fn(example_proto) # Reshape if self.save_image_in_records: image = decode_raw_image(parsed_features['image'], (227, 227, 3), image_size=self.image_size) else: filename = tf.decode_base64(parsed_features['image']) parsed_features['image_path'] = tf.identity(filename, name='image_path') image = decode_relative_image(filename, self.image_dir, image_size=self.image_size) parsed_features['image'] = tf.identity(image, name='image') # Class parsed_features['class_content'] = tf.to_int32(parsed_features['class_content']) parsed_features['class_style'] = tf.to_int32(parsed_features['class_style']) # Return if self.verbose: print_records(parsed_features) return parsed_features
def base64_decode_img(b64code): """ :param b64code: :return: """ # img_base64_data = base64.b64decode(b64code) # img_nparr = np.fromstring(img_base64_data, np.uint8) # img = cv2.imdecode(img_nparr, cv2.COLOR_BGR2RGB) # print('shape of img:{}'.format(img.shape)) base64_tensor = tf.convert_to_tensor(b64code, dtype=tf.string) img_str = tf.decode_base64(base64_tensor) img = tf.image.decode_image(img_str, channels=3) with tf.Session() as sess: # img_str_result = sess.run([img_str])[0] # print('img_str_result:{}'.format(img_str_result)) img_value = sess.run([img])[0] print(img_value.shape)
def main(): mnist = input_data.read_data_sets("./input_data") x = tf.placeholder(tf.float32, [None, 784]) logits = inference(x) y_ = tf.placeholder(tf.int64, [None]) cross_entropy = tf.losses.sparse_softmax_cross_entropy( labels=y_, logits=logits) train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy) init_op = tf.global_variables_initializer() # Define op for model signature tf.get_variable_scope().reuse_variables() model_base64_placeholder = tf.placeholder( shape=[None], dtype=tf.string, name="model_input_b64_images") model_base64_string = tf.decode_base64(model_base64_placeholder) model_base64_input = tf.map_fn(lambda x: tf.image.resize_images(tf.image.decode_jpeg(x, channels=1), [28, 28]), model_base64_string, dtype=tf.float32) model_base64_reshape_input = tf.reshape(model_base64_input, [-1, 28 * 28]) model_logits = inference(model_base64_reshape_input) model_predict_softmax = tf.nn.softmax(model_logits) model_predict = tf.argmax(model_predict_softmax, 1) with tf.Session() as sess: sess.run(init_op) for i in range(938): batch_xs, batch_ys = mnist.train.next_batch(64) sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys}) # Export image model export_dir = "./model/1" print("Try to export the model in {}".format(export_dir)) tf.saved_model.simple_save( sess, export_dir, inputs={"images": model_base64_placeholder}, outputs={ "predict": model_predict, "probability": model_predict_softmax })
def export_generator(): input_src = tf.placeholder(tf.string, shape=[1]) input_data = tf.decode_base64(input_src[0]) input_image = tf.image.decode_png(input_data) input_image = input_image[:, :, :3] input_image = tf.image.convert_image_dtype(input_image, dtype=tf.float32) input_image.set_shape([args['cropping'], args['cropping'], 3]) batch_input = tf.expand_dims(input_image, axis=0) with tf.variable_scope('generator') as scope: generator = gp.Generator(ds.preprocess(batch_input), 3, args['ngf']) batch_output = ds.deprocess(generator.build()) output_image = tf.image.convert_image_dtype(batch_output, dtype=tf.uint8)[0] output_data = tf.image.encode_jpeg(output_image, quality=100) output = tf.convert_to_tensor([tf.encode_base64(output_data)]) key = tf.placeholder(tf.string, shape=[1]) inputs = {"key": key.name, "input": input_src.name} tf.add_to_collection("inputs", json.dumps(inputs)) outputs = {"key": tf.identity(key).name, "output": output.name} tf.add_to_collection("outputs", json.dumps(outputs)) init_op = tf.global_variables_initializer() restore_saver = tf.train.Saver() export_saver = tf.train.Saver() with tf.Session() as sess: sess.run(init_op) print("loading model") # Loading previous model parameters checkpoint = tf.train.latest_checkpoint(args['checkpoint']) restore_saver.restore(sess, checkpoint) print("exporting model") export_saver.export_meta_graph( filename=os.path.join(args['results_dir'], "export.meta")) export_saver.save(sess, os.path.join(args['results_dir'], "export"), write_meta_graph=False)
def parsing_fn(self, example_proto): """tf.data.Dataset parsing function.""" # Parse parsed_features = self.raw_parsing_fn(example_proto) # Reshape if self.save_image_in_records: image = decode_raw_image(parsed_features['image'], (500, 500, 3), image_size=None) else: filename = tf.decode_base64(parsed_features['image']) parsed_features['image_path'] = tf.identity(filename, name='image_path') image = decode_relative_image(filename, self.image_dir, image_size=None) # Crop image to bounding box if self.crop_images: bounding_box = parsed_features['bounding_box'] if self.keep_crop_aspect_ratio: bounding_box = make_square_bounding_box(bounding_box, mode='max') image = tf.image.crop_and_resize( tf.expand_dims(image, axis=0), tf.expand_dims(bounding_box, axis=0), [0], (500, 500))[0] del parsed_features['bounding_box'] # Resize image after cropping if self.image_size is not None: image = tf.image.resize_images(image, (self.image_size, self.image_size)) parsed_features['image'] = tf.identity(image, name='image') # One-hot encode each attribute if self.one_hot_attributes: for key, num_values in self.attributes_values_list: parsed_features[key] = tf.one_hot(parsed_features[key], num_values, axis=-1, name='one_hot_%s' % key) # Return if self.verbose: print_records(parsed_features) return parsed_features
def ilsvrc_parsing_fn(example_proto, image_size=None, crop_size=None, image_dir=''): """ILSVRC parsing function. Load image from image_dir and resize them to `image_size`""" features = { 'image': tf.FixedLenFeature((), tf.string), 'class': tf.FixedLenFeature((), tf.int64), 'class_name': tf.FixedLenFeature((), tf.string) } parsed_features = tf.parse_single_example(example_proto, features) if crop_size is None or image_size is None: image = decode_relative_image(parsed_features['image'], image_dir, image_size=image_size) else: image = decode_relative_image(parsed_features['image'], image_dir, image_size=None) image = central_crop(image, image_size, crop_size) class_id = tf.to_int32(parsed_features['class']) class_name = tf.decode_base64(parsed_features['class_name']) return {'image': image, 'class': class_id, 'class_name': class_name}
def age_predict(request): import tensorflow as tf import os import numpy as np import base64 import json model = tf.keras.models.load_model(os.path.abspath('./my_model.h5')) model.compile(optimizer=tf.train.AdamOptimizer(), loss="mean_absolute_error", metrics=["mean_absolute_error"]) # * 处理前端的base64字符串,去掉头部, # * 并且转换为urlsafe形式,这是TensorFlow的要求,详情见 https://www.tensorflow.org/versions/r1.9/api_docs/python/tf/decode_base64?hl=en img_base64_header, img_base64 = json.loads(request.body)['base64_img'].split(",",1) raw = base64.decodestring(img_base64.encode('utf-8')) img_base64_websafe = base64.urlsafe_b64encode(raw) # * base转为tensor,然后输入模型 img_raw = tf.decode_base64(img_base64_websafe) image_tensor = tf.cast(tf.image.resize_images(tf.io.decode_jpeg(img_raw, channels=3), [192,192]),tf.float32) image = tf.expand_dims(image_tensor, axis=0) age = model.predict(image, steps=1) return HttpResponse(age)
def export_inception_with_base64_decode(model, hparams): from keras.models import Model from keras.layers import Dense print("check gpu") print(K.tensorflow_backend._get_available_gpus()) num_classes = 9 # Intermediate layer print('Defining the model') intermediate_layer_model = Model(inputs=model.input, outputs=model.layers[311].output) x = intermediate_layer_model.output x = Dense(1024, activation='relu', name='dense_relu')(x) predictions = Dense(num_classes, activation='softmax', name='dense_softmax')(x) transfer_model = Model(inputs=intermediate_layer_model.input, outputs=predictions) for layer in transfer_model.layers: layer.trainable = False # Unfreeze the last layers, so that only these layers are trainable. transfer_model.layers[312].trainable = True transfer_model.layers[313].trainable = True print('Training ...') transfer_model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) # flow from keras.preprocessing.image import ImageDataGenerator datagen = ImageDataGenerator(validation_split=0.25) train_generator = keras_gs.flow_from_google_storage(datagen, hparams.data_project, hparams.data_bucket, hparams.data_path, subset="training", target_size=(299, 299), batch_size=hparams.batch_size) validation_generator = keras_gs.flow_from_google_storage(datagen, hparams.data_project, hparams.data_bucket, hparams.data_path, subset="validation", target_size=(299, 299), batch_size=hparams.batch_size) history = transfer_model.fit_generator( train_generator, steps_per_epoch=hparams.steps_per_epoch, epochs=hparams.num_epochs, validation_data=validation_generator, validation_steps=hparams.validation_steps) acc = history.history['acc'] loss = history.history['loss'] print('Loss {}, Accuracy {}'.format(loss, acc)) print('Exporting ...') sess = K.get_session() g_trans = sess.graph g_trans_def = graph_util.convert_variables_to_constants(sess, g_trans.as_graph_def(), [transfer_model.output.name.replace(':0', '')]) # Step 1 : Build a graph that converts image with tf.Graph().as_default() as g_input: input_b64 = tf.placeholder( shape=(1,), dtype=tf.string, name='input') input_bytes = tf.decode_base64(input_b64[0]) img = tf.image.decode_image(input_bytes) image_f = tf.image.convert_image_dtype(img, dtype=tf.float32) input_image = tf.expand_dims(image_f, axis=0) tf.identity(input_image, name='input_image') # Convert to GraphDef g_input_def = g_input.as_graph_def() with tf.Graph().as_default() as g_combined: x = tf.placeholder(tf.string, name="input_b64") im, = tf.import_graph_def(g_input_def, input_map={'input:0': x}, return_elements=["input_image:0"]) pred, = tf.import_graph_def(g_trans_def, input_map={ transfer_model.input.name: im, 'batch_normalization_1/keras_learning_phase:0': False }, return_elements=[transfer_model.output.name]) with tf.Session() as sess2: inputs = {"inputs": tf.saved_model.utils.build_tensor_info(x)} outputs = {"outputs": tf.saved_model.utils.build_tensor_info(pred)} signature = tf.saved_model.signature_def_utils.build_signature_def( inputs=inputs, outputs=outputs, method_name=tf.saved_model.signature_constants.PREDICT_METHOD_NAME ) # save as SavedModel sess2.run(tf.global_variables_initializer()) b = tf.saved_model.builder.SavedModelBuilder(os.path.join(hparams.job_dir, "model")) b.add_meta_graph_and_variables(sess2, [tf.saved_model.tag_constants.SERVING], signature_def_map={'serving_default': signature}) b.save()
def decode_and_process(base64): _bytes = tf.decode_base64(base64) _image = __tf_jpeg_process(_bytes) return _image
def run(target, is_chief, job_name, a): output_dir = "./export" if tf.__version__.split('.')[0] != "1": raise Exception("Tensorflow version 1 required") if a.seed is None: a.seed = random.randint(0, 2**31 - 1) tf.set_random_seed(a.seed) np.random.seed(a.seed) random.seed(a.seed) for k, v in a._get_kwargs(): print(k, "=", v) if a.checkpoint is None: raise Exception("checkpoint required for test mode") # load some options from the checkpoint # disable these features in test mode a.scale_size = CROP_SIZE a.flip = False input = tf.placeholder(tf.string, shape=[1]) input_data = tf.decode_base64(input[0]) input_image = tf.image.decode_png(input_data) # remove alpha channel if present input_image = tf.cond(tf.equal(tf.shape(input_image)[2], 4), lambda: input_image[:, :, :3], lambda: input_image) # convert grayscale to RGB input_image = tf.cond(tf.equal(tf.shape(input_image)[2], 1), lambda: tf.image.grayscale_to_rgb(input_image), lambda: input_image) input_image = tf.image.convert_image_dtype(input_image, dtype=tf.float32) input_image.set_shape([CROP_SIZE, CROP_SIZE, 3]) batch_input = tf.expand_dims(input_image, axis=0) with tf.variable_scope("generator"): batch_output = model.deprocess( model.create_generator(a.num_generator_filters, model.preprocess(batch_input), 3)) output_image = tf.image.convert_image_dtype(batch_output, dtype=tf.uint8)[0] if a.output_filetype == "jpeg": output_data = tf.image.encode_jpeg(output_image, quality=80) else: output_data = tf.image.encode_png(output_image) output = tf.convert_to_tensor([tf.encode_base64(output_data)]) key = tf.placeholder(tf.string, shape=[1]) inputs = {"key": key.name, "input": input.name} tf.add_to_collection("inputs", json.dumps(inputs)) outputs = { "key": tf.identity(key).name, "output": output.name, } tf.add_to_collection("outputs", json.dumps(outputs)) init_op = tf.global_variables_initializer() restore_saver = tf.train.Saver() export_saver = tf.train.Saver() with tf.Session() as sess: print("monitored session created.") sess.run(init_op) print("loading model from checkpoint") checkpoint = tf.train.latest_checkpoint(a.checkpoint) restore_saver.restore(sess, checkpoint) # ready to process image print("exporting model") export_saver.export_meta_graph( filename=os.path.join(output_dir, "export.meta")) export_saver.save(sess, os.path.join(output_dir, "export"), write_meta_graph=False)
def main(): if a.seed is None: a.seed = random.randint(0, 2**31 - 1) tf.set_random_seed(a.seed) np.random.seed(a.seed) random.seed(a.seed) if not os.path.exists(a.output_dir): os.makedirs(a.output_dir) if a.mode == "test" or a.mode == "export": if a.checkpoint is None: raise Exception("checkpoint required for test mode") # load some options from the checkpoint options = {"which_direction", "ngf", "ndf", "lab_colorization"} with open(os.path.join(a.checkpoint, "options.json")) as f: for key, val in json.loads(f.read()).items(): if key in options: print("loaded", key, "=", val) setattr(a, key, val) a.flip = False for k, v in a._get_kwargs(): print(k, "=", v) with open(os.path.join(a.output_dir, "options.json"), "w") as f: f.write(json.dumps(vars(a), sort_keys=True, indent=4)) if a.mode == "export": # export the generator to a meta graph that can be imported later for standalone generation if a.lab_colorization: raise Exception("export not supported for lab_colorization") input = tf.placeholder(tf.string, shape=[1]) input_data = tf.decode_base64(input[0]) input_image = tf.image.decode_png(input_data) # remove alpha channel if present input_image = tf.cond(tf.equal(tf.shape(input_image)[2], 4), lambda: input_image[:,:,:3], lambda: input_image) # convert grayscale to RGB input_image = tf.cond(tf.equal(tf.shape(input_image)[2], 1), lambda: tf.image.grayscale_to_rgb(input_image), lambda: input_image) input_image = tf.image.convert_image_dtype(input_image, dtype=tf.float32) # commented by (kjh) # input_image.set_shape([CROP_SIZE, CROP_SIZE, 3]) batch_input = tf.expand_dims(input_image, axis=0) with tf.variable_scope("generator"): batch_output = deprocess(create_generator(preprocess(batch_input), 3)) output_image = tf.image.convert_image_dtype(batch_output, dtype=tf.uint8)[0] if a.output_filetype == "png": output_data = tf.image.encode_png(output_image) elif a.output_filetype == "jpeg": output_data = tf.image.encode_jpeg(output_image, quality=80) else: raise Exception("invalid filetype") output = tf.convert_to_tensor([tf.encode_base64(output_data)]) key = tf.placeholder(tf.string, shape=[1]) inputs = { "key": key.name, "input": input.name } tf.add_to_collection("inputs", json.dumps(inputs)) outputs = { "key": tf.identity(key).name, "output": output.name, } tf.add_to_collection("outputs", json.dumps(outputs)) init_op = tf.global_variables_initializer() restore_saver = tf.train.Saver() export_saver = tf.train.Saver() with tf.Session() as sess: sess.run(init_op) print("loading model from checkpoint") checkpoint = tf.train.latest_checkpoint(a.checkpoint) restore_saver.restore(sess, checkpoint) print("exporting model") export_saver.export_meta_graph(filename=os.path.join(a.output_dir, "export.meta")) export_saver.save(sess, os.path.join(a.output_dir, "export"), write_meta_graph=False) return img = tf.placeholder(tf.float32) input_img, target_img, segment_img = load_examples(img) lbs = tf.placeholder(tf.float32) lbsw = tf.placeholder(tf.float32) bboxt = tf.placeholder(tf.float32) bboxlw = tf.placeholder(tf.float32) steps_per_epoch = int(N / a.batch_size) print("examples count = %d" % N) # inputs and targets are [batch_size, height, width, channels] model = create_model(input_img, target_img, segment_img, lbs, lbsw, bboxt, bboxlw) inputs = deprocess(input_img) targets = deprocess(target_img) outputs = deprocess(model.outputs) def convert(image): # commented by (kjh) # if a.aspect_ratio != 1.0: # # upscale to correct aspect ratio # size = [CROP_SIZE, int(round(CROP_SIZE * a.aspect_ratio))] image = tf.image.resize_images(image, size=[512,640], method=tf.image.ResizeMethod.BICUBIC) return tf.image.convert_image_dtype(image, dtype=tf.uint8, saturate=True) # reverse any processing on images so they can be written to disk or displayed to user with tf.name_scope("convert_inputs"): converted_inputs = convert(inputs) with tf.name_scope("convert_targets"): converted_targets = convert(targets) with tf.name_scope("convert_outputs"): converted_outputs = convert(outputs) with tf.name_scope("convert_segment"): converted_segment = convert(model.seg_result) with tf.name_scope("encode_images"): display_fetches = { # "paths": examples.paths, "inputs": tf.map_fn(tf.image.encode_png, converted_inputs, dtype=tf.string, name="input_pngs"), "targets": tf.map_fn(tf.image.encode_png, converted_targets, dtype=tf.string, name="target_pngs"), "outputs": tf.map_fn(tf.image.encode_png, converted_outputs, dtype=tf.string, name="output_pngs"), "segment": tf.map_fn(tf.image.encode_png, converted_segment, dtype=tf.string, name="segment_pngs"), } # summaries with tf.name_scope("inputs_summary"): tf.summary.image("inputs", converted_inputs) with tf.name_scope("targets_summary"): tf.summary.image("targets", converted_targets) with tf.name_scope("outputs_summary"): tf.summary.image("outputs", converted_outputs) with tf.name_scope("segment_summary"): tf.summary.image("segment", converted_segment) with tf.name_scope("predict_real_summary"): tf.summary.image("predict_real", tf.image.convert_image_dtype(model.predict_real, dtype=tf.uint8)) with tf.name_scope("predict_fake_summary"): tf.summary.image("predict_fake", tf.image.convert_image_dtype(model.predict_fake, dtype=tf.uint8)) tf.summary.scalar("discriminator_loss_GAN", model.discrim_loss_GAN) tf.summary.scalar("discriminator_loss_segment", model.discrim_loss_segment) tf.summary.scalar("discriminator_loss_cls", model.discrim_loss_cls) tf.summary.scalar("discriminator_loss_bbox", model.discrim_loss_bbox) tf.summary.scalar("generator_loss_GAN", model.gen_loss_GAN) tf.summary.scalar("generator_loss_L1", model.gen_loss_L1) for var in tf.trainable_variables(): tf.summary.histogram(var.op.name + "/values", var) for grad, var in model.discrim_grads_and_vars + model.gen_grads_and_vars: tf.summary.histogram(var.op.name + "/gradients", grad) with tf.name_scope("parameter_count"): parameter_count = tf.reduce_sum([tf.reduce_prod(tf.shape(v)) for v in tf.trainable_variables()]) # max_to_keep: how many latest models will you save, to save all of them, set it to 'None' (kjh) saver = tf.train.Saver(max_to_keep=None) logdir = a.output_dir if (a.trace_freq > 0 or a.summary_freq > 0) else None sv = tf.train.Supervisor(logdir=logdir, save_summaries_secs=0, saver=None) with sv.managed_session() as sess: print("parameter_count =", sess.run(parameter_count)) # if a.checkpoint is not None: # print("loading model from checkpoint") # checkpoint = tf.train.latest_checkpoint(a.checkpoint) # saver.restore(sess, checkpoint) # saver.restore(sess, 'D:/pix2pix/ped_train/model-300000') max_steps = 2**32 if a.max_epochs is not None: max_steps = steps_per_epoch * a.max_epochs if a.max_steps is not None: max_steps = a.max_steps if a.mode == "test": # testing # at most, process the test data once for m in range(400000//a.save_freq): if m==400000//a.save_freq-1: checkpoint = tf.train.latest_checkpoint(a.checkpoint) saver.restore(sess, checkpoint) model_name = 'last' else: model_name = str(a.save_freq*(m+1)) saver.restore(sess, 'D:/pix2pix/ped_train/model-'+model_name) start = time.time() max_steps = min(steps_per_epoch, max_steps) for step in range(max_steps): image = cv2.imread(input_paths[step]) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) name, _ = os.path.splitext(os.path.basename(input_paths[step])) image = add_noise(image,name,a.mode) # thermal image is not used for testing # [display_fetches, model.cls_result, model.bbox_result] display_result, cls_output, bbox_output = sess.run([display_fetches, model.cls_result, model.bbox_result], feed_dict={img: image}) filesets = save_images(display_result, name, model_name=model_name) for i, f in enumerate(filesets): print("evaluated image", f["name"]) index_path = append_index(filesets) bbox_dir = os.path.join(a.output_dir, "detection_result"+'-'+model_name) if not os.path.exists(bbox_dir): os.makedirs(bbox_dir) bbox_result={"cls": cls_output, "bbox": bbox_output} bbox_path = os.path.join(bbox_dir,name) scipy.io.savemat(bbox_path, bbox_result) print("wrote index at", index_path) print("rate", (time.time() - start) / max_steps) else: # training start = time.time() L = list(range(N)) random.seed(1) random.shuffle(L) n = 0 for step in range(max_steps): def should(freq): return freq > 0 and ((step + 1) % freq == 0 or step == max_steps - 1) if n == N: random.shuffle(L) n = 0 options = None run_metadata = None if should(a.trace_freq): options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE) run_metadata = tf.RunMetadata() fetches = { "train": model.train, "global_step": sv.global_step, } if should(a.progress_freq): fetches["discrim_loss_GAN"] = model.discrim_loss_GAN fetches["discrim_loss_segment"] = model.discrim_loss_segment fetches["discrim_loss_cls"] = model.discrim_loss_cls fetches["discrim_loss_bbox"] = model.discrim_loss_bbox fetches["gen_loss_GAN"] = model.gen_loss_GAN fetches["gen_loss_L1"] = model.gen_loss_L1 if should(a.summary_freq): fetches["summary"] = sv.summary_op if should(a.display_freq): fetches["display"] = display_fetches # load image and gt image = cv2.imread(input_paths[L[n]]) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) name, _ = os.path.splitext(os.path.basename(input_paths[L[n]])) image = add_noise(image, name, a.mode) mat = scipy.io.loadmat(os.path.join(bbox_paths, name)) labels, label_weights, bbox_targets, bbox_loss_weights = sample_minibatch(mat['bbox_targets']) results = sess.run(fetches, options=options, run_metadata=run_metadata, feed_dict={img: image, lbs: labels, lbsw:label_weights, bboxt:bbox_targets, bboxlw:bbox_loss_weights}) # results = sess.run(fetches, options=options, run_metadata=run_metadata) n = n + 1 if should(a.summary_freq): print("recording summary") sv.summary_writer.add_summary(results["summary"], results["global_step"]) if should(a.display_freq): print("saving display images") filesets = save_images(results["display"], name, step=results["global_step"]) append_index(filesets, step=True) if should(a.trace_freq): print("recording trace") sv.summary_writer.add_run_metadata(run_metadata, "step_%d" % results["global_step"]) if should(a.progress_freq): # global_step will have the correct step count if we resume from a checkpoint train_epoch = math.ceil(results["global_step"] / steps_per_epoch) train_step = (results["global_step"] - 1) % steps_per_epoch + 1 rate = (step + 1) * a.batch_size / (time.time() - start) remaining = (max_steps - step) * a.batch_size / rate print("progress epoch %d step %d image/sec %0.1f remaining %dm" % (train_epoch, train_step, rate, remaining / 60)) print("discrim_loss_GAN", results["discrim_loss_GAN"]) print("gen_loss_GAN", results["gen_loss_GAN"]) print("discrim_loss_segment", results["discrim_loss_segment"]) print("discrim_loss_cls", results["discrim_loss_cls"]) print("discrim_loss_bbox", results["discrim_loss_bbox"]) print("gen_loss_L1", results["gen_loss_L1"]) if should(a.save_freq): print("saving model") saver.save(sess, os.path.join(a.output_dir, "model"), global_step=sv.global_step) if sv.should_stop(): break
def main(): if tf.__version__.split('.')[0] != "1": raise Exception("Tensorflow version 1 required") if a.seed is None: a.seed = random.randint(0, 2**31 - 1) tf.set_random_seed(a.seed) np.random.seed(a.seed) random.seed(a.seed) if not os.path.exists(a.output_dir): os.makedirs(a.output_dir) if a.mode == "test" or a.mode == "export": if a.checkpoint is None: raise Exception("checkpoint required for test mode") # load some options from the checkpoint options = {"which_direction", "ngf", "ndf", "lab_colorization"} with open(os.path.join(a.checkpoint, "options.json")) as f: for key, val in json.loads(f.read()).items(): if key in options: print("loaded", key, "=", val) setattr(a, key, val) # disable these features in test mode a.scale_size = CROP_SIZE a.flip = False for k, v in a._get_kwargs(): print(k, "=", v) with open(os.path.join(a.output_dir, "options.json"), "w") as f: f.write(json.dumps(vars(a), sort_keys=True, indent=4)) if a.mode == "export": # export the generator to a meta graph that can be imported later for standalone generation if a.lab_colorization: raise Exception("export not supported for lab_colorization") input = tf.placeholder(tf.string, shape=[1], name="input_base64") input_data = tf.decode_base64(input[0]) input_image = tf.image.decode_png(input_data) # remove alpha channel if present input_image = tf.cond(tf.equal(tf.shape(input_image)[2], 4), lambda: input_image[:, :, :3], lambda: input_image) # convert grayscale to RGB input_image = tf.cond(tf.equal(tf.shape(input_image)[2], 1), lambda: tf.image.grayscale_to_rgb(input_image), lambda: input_image) input_image = tf.image.convert_image_dtype(input_image, dtype=tf.float32) input_image.set_shape([CROP_SIZE, CROP_SIZE, 3]) batch_input = tf.expand_dims(input_image, axis=0) with tf.variable_scope("generator"): batch_output = deprocess( create_generator(preprocess(batch_input), 3)) output_image = tf.image.convert_image_dtype(batch_output, dtype=tf.uint8)[0] if a.output_filetype == "png": output_data = tf.image.encode_png(output_image) elif a.output_filetype == "jpeg": output_data = tf.image.encode_jpeg(output_image, quality=80) else: raise Exception("invalid filetype") output = tf.convert_to_tensor([tf.encode_base64(output_data)], name="output_base64") init_op = tf.global_variables_initializer() restore_saver = tf.train.Saver() export_saver = tf.train.Saver() with tf.Session() as sess: sess.run(init_op) print("loading model from checkpoint") checkpoint = tf.train.latest_checkpoint(a.checkpoint) restore_saver.restore(sess, checkpoint) print("exporting model") exports_dir = os.path.abspath(os.path.join(a.output_dir, 'export')) if not os.path.exists(exports_dir): os.makedirs(exports_dir) model_exporter = exporter.Exporter(export_saver) model_exporter.init(sess.graph.as_graph_def(), named_graph_signatures={ 'inputs': exporter.generic_signature({'x': input}), 'outputs': exporter.generic_signature( {'predictions': output}) }) model_exporter.export(export_dir_base=exports_dir, global_step_tensor=tf.constant(2), sess=sess) # export_saver.export_meta_graph(filename=os.path.join(a.output_dir, "export.meta")) # export_saver.save(sess, os.path.join(a.output_dir, "export"), write_meta_graph=False) return examples = load_examples() print("examples count = %d" % examples.count) final_input = tf.placeholder_with_default(examples.inputs, shape=(None, CROP_SIZE, CROP_SIZE, 3), name="final_input") final_dropout = tf.placeholder(tf.float32, name='final_dropout') # inputs and targets are [batch_size, height, width, channels] model = create_model(final_input, examples.targets, final_dropout) # undo colorization splitting on images that we use for display/output if a.lab_colorization: if a.which_direction == "AtoB": # inputs is brightness, this will be handled fine as a grayscale image # need to augment targets and outputs with brightness targets = augment(examples.targets, examples.inputs) outputs = augment(model.outputs, examples.inputs) # inputs can be deprocessed normally and handled as if they are single channel # grayscale images inputs = deprocess(examples.inputs) elif a.which_direction == "BtoA": # inputs will be color channels only, get brightness from targets inputs = augment(examples.inputs, examples.targets) targets = deprocess(examples.targets) outputs = deprocess(model.outputs) else: raise Exception("invalid direction") else: inputs = examples.inputs targets = tf.argmax(examples.targets, axis=-1) # targets = examples.targets targets = tf.expand_dims(targets, axis=-1) outputs = tf.argmax(model.outputs, axis=-1) outputs = tf.expand_dims(outputs, axis=-1) # Image summary. def depreprocess(image_batch, num_images, img_mean, img_std): b, h, w, c = image_batch.shape outputs = [] if num_images > b: num_images = b for i in range(num_images): input_plus_mean = img_std * image_batch[i] + img_mean input_casted = tf.cast(input_plus_mean, tf.uint8) outputs.append(input_casted) return tf.stack(outputs) # reverse any processing on images so they can be written to disk or displayed to user with tf.name_scope("convert_inputs"): converted_inputs = depreprocess(inputs, num_images=3, img_mean=IMG_RGB_MEAN, img_std=IMG_RGB_STD) with tf.name_scope("convert_targets"): converted_targets = (targets * (np.round(256 / (NUM_OF_CLASSESS - 1)) - 1)) # converted_targets = 100 * targets # converted_targets = convert(converted_targets) converted_targets = tf.cast(converted_targets, tf.uint8) with tf.name_scope("convert_outputs"): # converted_outputs = 100 * outputs converted_outputs = (outputs * (np.round(256 / (NUM_OF_CLASSESS - 1)) - 1)) # converted_outputs = convert(converted_outputs) converted_outputs = tf.cast(converted_outputs, tf.uint8) # converted_outputs = color_image(converted_outputs, NUM_OF_CLASSESS) with tf.name_scope("encode_images"): display_fetches = { "paths": examples.paths, "inputs": tf.map_fn(tf.image.encode_png, converted_inputs, dtype=tf.string, name="input_pngs"), "targets": tf.map_fn(tf.image.encode_png, converted_targets, dtype=tf.string, name="target_pngs"), "outputs": tf.map_fn(tf.image.encode_png, converted_outputs, dtype=tf.string, name="output_pngs"), } # summaries with tf.name_scope("inputs_summary"): tf.summary.image("inputs", converted_inputs) with tf.name_scope("targets_summary"): tf.summary.image("targets", converted_targets) with tf.name_scope("outputs_summary"): tf.summary.image("outputs", converted_outputs) tf.summary.scalar("gen_loss", model.gen_loss) tf.summary.scalar("learning_rate", model.lr_rate) for var in tf.trainable_variables(): tf.summary.histogram(var.op.name + "/values", var) for grad, var in model.gen_grads_and_vars: tf.summary.histogram(var.op.name + "/gradients", grad) with tf.name_scope("parameter_count"): parameter_count = tf.reduce_sum( [tf.reduce_prod(tf.shape(v)) for v in tf.trainable_variables()]) saver = tf.train.Saver(max_to_keep=1) logdir = a.output_dir if (a.trace_freq > 0 or a.summary_freq > 0) else None sv = tf.train.Supervisor(logdir=logdir, save_summaries_secs=0, saver=None) with sv.managed_session() as sess: print("parameter_count =", sess.run(parameter_count)) if a.checkpoint is not None: print("loading model from checkpoint") checkpoint = tf.train.latest_checkpoint(a.checkpoint) saver.restore(sess, checkpoint) max_steps = 2**32 if a.max_epochs is not None: max_steps = examples.steps_per_epoch * a.max_epochs if a.max_steps is not None: max_steps = a.max_steps if a.mode == "test": # testing # at most, process the test data once max_steps = min(examples.steps_per_epoch, max_steps) for step in range(max_steps): results = sess.run(display_fetches) filesets = save_images(results) for i, f in enumerate(filesets): print("evaluated image", f["name"]) index_path = append_index(filesets) print("wrote index at", index_path) else: # training start = time.time() for step in range(max_steps): def should(freq): return freq > 0 and ((step + 1) % freq == 0 or step == max_steps - 1) options = None run_metadata = None if should(a.trace_freq): options = tf.RunOptions( trace_level=tf.RunOptions.FULL_TRACE) run_metadata = tf.RunMetadata() fetches = { "train": model.train, "global_step": sv.global_step, } if should(a.progress_freq): fetches["gen_loss"] = model.gen_loss if should(a.summary_freq): fetches["summary"] = sv.summary_op if should(a.display_freq): fetches["display"] = display_fetches results = sess.run(fetches, feed_dict={final_dropout: 0.5}, options=options, run_metadata=run_metadata) if should(a.summary_freq): print("recording summary") sv.summary_writer.add_summary(results["summary"], results["global_step"]) if should(a.display_freq): print("saving display images") filesets = save_images(results["display"], step=results["global_step"]) append_index(filesets, step=True) if should(a.trace_freq): print("recording trace") sv.summary_writer.add_run_metadata( run_metadata, "step_%d" % results["global_step"]) if should(a.progress_freq): # global_step will have the correct step count if we resume from a checkpoint train_epoch = math.ceil(results["global_step"] / examples.steps_per_epoch) train_step = (results["global_step"] - 1) % examples.steps_per_epoch + 1 rate = (step + 1) * a.batch_size / (time.time() - start) remaining = (max_steps - step) * a.batch_size / rate print( "progress epoch %d step %d image/sec %0.1f remaining %dm" % (train_epoch, train_step, rate, remaining / 60)) print("gen_loss", results["gen_loss"]) if should(a.save_freq): print("saving model") saver.save(sess, os.path.join(a.output_dir, "model"), global_step=sv.global_step) if sv.should_stop(): break
def _decode_base64(): return tf.decode_base64(image_tensor)
def _decode_base64(): return tf.decode_base64(image_tensor)
import tensorflow as tf import base64 f = open("/Users/xingoo/PycharmProjects/ai/test/3.jpg", 'rb') file_content = f.read() base64str = str(base64.urlsafe_b64encode(file_content), encoding='utf-8') base64_tensor = tf.convert_to_tensor(base64str, dtype=tf.string) print(base64_tensor) img_str = tf.decode_base64(base64_tensor) #得到(width, height, channel)的图像tensor img = tf.image.decode_image(img_str, channels=3) with tf.Session() as sess: img_value = sess.run([img])[0] #得到numpy array类型的数据 print(img_value.shape)
def main(argv): if a.seed is None: a.seed = random.randint(0, 2**31 - 1) # for reproducing tf.set_random_seed(a.seed) np.random.seed(a.seed) random.seed(a.seed) if not os.path.exists(a.output_dir): os.makedirs(a.output_dir) if a.mode == "test" or a.mode == "export": if a.checkpoint is None: raise Exception("checkpoint required for test mode") # load some options from the checkpoint options = {"which_direction", "ngf", "ndf", "lab_colorization"} with open(os.path.join(a.checkpoint, "options.json")) as f: for key, val in json.loads(f.read()).items(): if key in options: print("loaded", key, "=", val) setattr(a, key, val) # disable these features in test mode a.scale_size = CROP_SIZE a.flip = False for k, v in a._get_kwargs(): print(k, "=", v) with open(os.path.join(a.output_dir, "options.json"), "w") as f: f.write(json.dumps(vars(a), sort_keys=True, indent=4)) if a.mode == "export": # export the generator to a meta graph that can be imported later for standalone generation if a.lab_colorization: raise Exception("export not supported for lab_colorization") input = tf.placeholder(tf.string, shape=[1]) input_data = tf.decode_base64(input[0]) input_image = tf.image.decode_png(input_data) # remove alpha channel if present input_image = tf.cond(tf.equal(tf.shape(input_image)[2], 4), lambda: input_image[:, :, :3], lambda: input_image) # convert grayscale to RGB input_image = tf.cond(tf.equal(tf.shape(input_image)[2], 1), lambda: tf.image.grayscale_to_rgb(input_image), lambda: input_image) input_image = tf.image.convert_image_dtype(input_image, dtype=tf.float32) input_image.set_shape([CROP_SIZE, CROP_SIZE, 3]) batch_input = tf.expand_dims(input_image, axis=0) with tf.variable_scope("generator"): batch_output = deprocess( create_generator(preprocess(batch_input), 3, a.ngf)) output_image = tf.image.convert_image_dtype(batch_output, dtype=tf.uint8)[0] if a.output_filetype == "png": output_data = tf.image.encode_png(output_image) elif a.output_filetype == "jpeg": output_data = tf.image.encode_jpeg(output_image, quality=80) else: raise Exception("invalid filetype") output = tf.convert_to_tensor([tf.encode_base64(output_data)]) key = tf.placeholder(tf.string, shape=[1]) inputs = {"key": key.name, "input": input.name} tf.add_to_collection("inputs", json.dumps(inputs)) outputs = { "key": tf.identity(key).name, "output": output.name, } tf.add_to_collection("outputs", json.dumps(outputs)) init_op = tf.global_variables_initializer() restore_saver = tf.train.Saver() export_saver = tf.train.Saver() with tf.Session() as sess: sess.run(init_op) print("loading model from checkpoint") checkpoint = tf.train.latest_checkpoint(a.checkpoint) restore_saver.restore(sess, checkpoint) print("exporting model") export_saver.export_meta_graph( filename=os.path.join(a.output_dir, "export.meta")) export_saver.save(sess, os.path.join(a.output_dir, "export"), write_meta_graph=False) return # prepare dataset examples = load_batch_examples(a) print("examples count = %d" % examples.count) # pix2pix model out_channels = int(examples.targets.get_shape()[-1]) pix_model = pix2pix(a, out_channels) # inputs and targets are [batch_size, height, width, channels] model = pix_model.create_model(examples.inputs, examples.targets) # undo colorization splitting on images that we use for display/output if a.lab_colorization: if a.which_direction == "AtoB": # inputs is brightness, this will be handled fine as a grayscale image # need to augment targets and outputs with brightness targets = augment(examples.targets, examples.inputs) outputs = augment(model.outputs, examples.inputs) # inputs can be deprocessed normally and handled as if they are single channel # grayscale images inputs = deprocess(examples.inputs) elif a.which_direction == "BtoA": # inputs will be color channels only, get brightness from targets inputs = augment(examples.inputs, examples.targets) targets = deprocess(examples.targets) outputs = deprocess(model.outputs) else: raise Exception("invalid direction") else: inputs = deprocess(examples.inputs) targets = deprocess(examples.targets) outputs = deprocess(model.outputs) def convert(image): if a.aspect_ratio != 1.0: # upscale to correct aspect ratio size = [CROP_SIZE, int(round(CROP_SIZE * a.aspect_ratio))] image = tf.image.resize_images( image, size=size, method=tf.image.ResizeMethod.BICUBIC) return tf.image.convert_image_dtype(image, dtype=tf.uint8, saturate=True) # reverse any processing on images so they can be written to disk or displayed to user with tf.name_scope("convert_inputs"): converted_inputs = convert(inputs) with tf.name_scope("convert_targets"): converted_targets = convert(targets) with tf.name_scope("convert_outputs"): converted_outputs = convert(outputs) with tf.name_scope("encode_images"): display_fetches = { "paths": examples.paths, "inputs": tf.map_fn(tf.image.encode_png, converted_inputs, dtype=tf.string, name="input_pngs"), "targets": tf.map_fn(tf.image.encode_png, converted_targets, dtype=tf.string, name="target_pngs"), "outputs": tf.map_fn(tf.image.encode_png, converted_outputs, dtype=tf.string, name="output_pngs"), } # summaries with tf.name_scope("inputs_summary"): tf.summary.image("inputs", converted_inputs) with tf.name_scope("targets_summary"): tf.summary.image("targets", converted_targets) with tf.name_scope("outputs_summary"): tf.summary.image("outputs", converted_outputs) with tf.name_scope("predict_real_summary"): tf.summary.image( "predict_real", tf.image.convert_image_dtype(model.predict_real, dtype=tf.uint8)) with tf.name_scope("predict_fake_summary"): tf.summary.image( "predict_fake", tf.image.convert_image_dtype(model.predict_fake, dtype=tf.uint8)) tf.summary.scalar("discriminator_loss", model.discrim_loss) tf.summary.scalar("generator_loss_GAN", model.gen_loss_GAN) tf.summary.scalar("generator_loss_L1", model.gen_loss_L1) for var in tf.trainable_variables(): tf.summary.histogram(var.op.name + "/values", var) for grad, var in model.discrim_grads_and_vars + model.gen_grads_and_vars: tf.summary.histogram(var.op.name + "/gradients", grad) with tf.name_scope("parameter_count"): parameter_count = tf.reduce_sum( [tf.reduce_prod(tf.shape(v)) for v in tf.trainable_variables()]) # compute max_steps max_steps = 2**32 if a.max_epochs is not None: max_steps = examples.steps_per_epoch * a.max_epochs if a.max_steps is not None: max_steps = a.max_steps # to save checkpoint saver = tf.train.Saver(max_to_keep=1) # log directory logdir = a.output_dir if (a.trace_freq > 0 or a.summary_freq > 0) else None # use differnt hooks for training and testing if a.mode == "test": hooks = None else: # hooks for tf.train.MonitoredTrainingSession from networks.custom_hooks import TraceHook, DisplayHook, LoggingTensorHook # train_hooks = [ tf.train.StopAtStepHook(last_step=max_steps), ] if a.checkpoint: train_hooks.append( tf.train.CheckpointSaverHook(checkpoint_dir=a.checkpoint, save_steps=a.save_freq, saver=saver)) if a.summary_freq: train_hooks.append( tf.train.SummarySaverHook( save_steps=a.summary_freq, output_dir=logdir, scaffold=tf.train.Scaffold( summary_op=tf.summary.merge_all()))) if a.progress_freq: train_hooks.append( LoggingTensorHook( tensors={ "discrim_loss": model.discrim_loss, "gen_loss_GAN": model.gen_loss_GAN, "gen_loss_L1": model.gen_loss_L1 }, batch_size=a.batch_size, max_steps=max_steps, steps_per_epoch=examples.steps_per_epoch, every_n_iter=a.progress_freq, )) if a.trace_freq: train_hooks.append( TraceHook(ckptdir=logdir, every_n_step=a.trace_freq)) if a.display_freq: train_hooks.append( DisplayHook(display_fetches, a.output_dir, every_n_step=a.display_freq)) # hooks = train_hooks # don't take the whole memory config = tf.ConfigProto() config.gpu_options.allow_growth = True #pylint: disable=E1101 # another way to do it #config = tf.ConfigProto(gpu_options=tf.GPUOptions(allow_growth=True)) with tf.train.MonitoredTrainingSession(hooks=hooks, config=config) as sess: print("parameter_count =", sess.run(parameter_count)) # load previous checkpoint if a.checkpoint is not None: print("loading model from checkpoint") checkpoint = tf.train.latest_checkpoint(a.checkpoint) saver.restore(sess, checkpoint) if a.mode == "test": # testing # at most, process the test data once start = time.time() max_steps = min(examples.steps_per_epoch, max_steps) for _ in range(max_steps): results = sess.run(display_fetches) filesets = save_images(results, a.output_dir) for i, f in enumerate(filesets): print("{}: evaluated image: {}".format(i, f["name"])) index_path = append_index(filesets, a.output_dir) print("wrote index at", index_path) print("rate", (time.time() - start) / max_steps) else: # training only while not sess.should_stop(): # fetches = { "train": model.train, # "global_step": tf.training_util._get_or_create_global_step_read(), #pylint: disable=protected-access } # the run results = sess.run(fetches)
import numpy as np import tensorflow as tf # tf.enable_eager_execution must be called at program startup. tf.enable_eager_execution() print(tf.add(1, 2)) print(tf.add([1, 2], [3, 4])) print(tf.square(5)) print(tf.reduce_sum([1, 2, 3])) print(tf.encode_base64("hello world")) print(tf.decode_base64('aGVsbG8gd29ybGQ')) # Operator overloading is also supported print(tf.square(2) + tf.square(3)) # The most obvious differences between NumPy arrays and TensorFlow Tensors are: # # Tensors can be backed by accelerator memory (like GPU, TPU). # Tensors are immutable. ndarray = np.ones([3, 3]) print("TensorFlow operations convert numpy arrays to Tensors automatically") tensor = tf.multiply(ndarray, 42) print(tensor) print("And NumPy operations convert Tensors to numpy arrays automatically") print(np.add(tensor, 1))
print('Hashing:\nfast:%s\nstrong:%s\nnormal:%s\n\n' % (result[0], result[1], result[2])) # 把数组连接为字符串 c = tf.reduce_join([a, b], axis=0) d = tf.string_join([a, b], '__') result = sess.run([c, d]) print('Joining:\nc=%s\nd=%s\n\n' % (result[0], result[1])) # 分割字符串 c = tf.string_split([a], ',') d = tf.substr(a, 0, 5) result = sess.run([c, d]) print('Spliting:\nc=%s\nd=%s\n\n' % (result[0][1], result[1])) # 转换字符串 c = tf.as_string(tf.constant(10)) d = tf.string_to_number(c) e = tf.encode_base64(a) f = tf.decode_base64(e) result = sess.run([c, d, e, f]) print('Conversion:\nc=%s\nd=%s\ne=%s\nf=%s\n\n' % (result[0], result[1], result[2], result[3])) sess.close()
def main(): # Get hyper-parameters print("Start Pokemon classifier") if os.path.exists(FLAGS.checkpoint_path) == False: os.makedirs(FLAGS.checkpoint_path) CHECKPOINT_FILE = FLAGS.checkpoint_path + "/checkpoint.ckpt" LATEST_CHECKPOINT = tf.train.latest_checkpoint(FLAGS.checkpoint_path) # Initialize train and test data TRAIN_IMAGE_NUMBER = 646 TEST_IMAGE_NUMBER = 68 IMAGE_SIZE = 32 RGB_CHANNEL_SIZE = 3 LABEL_SIZE = 17 train_dataset = np.ndarray(shape=(TRAIN_IMAGE_NUMBER, IMAGE_SIZE, IMAGE_SIZE, RGB_CHANNEL_SIZE), dtype=np.float32) test_dataset = np.ndarray(shape=(TEST_IMAGE_NUMBER, IMAGE_SIZE, IMAGE_SIZE, RGB_CHANNEL_SIZE), dtype=np.float32) train_labels = np.ndarray(shape=(TRAIN_IMAGE_NUMBER, ), dtype=np.int32) test_labels = np.ndarray(shape=(TEST_IMAGE_NUMBER, ), dtype=np.int32) TRAIN_DATA_DIR = "./data/train/" TEST_DATA_DIR = "./data/test/" VALIDATE_DATA_DIR = "./data/validate/" IMAGE_FORMAT = ".png" index = 0 pokemon_type_id_map = { "Bug": 0, "Dark": 1, "Dragon": 2, "Electric": 3, "Fairy": 4, "Fighting": 5, "Fire": 6, "Ghost": 7, "Grass": 8, "Ground": 9, "Ice": 10, "Normal": 11, "Poison": 12, "Psychic": 13, "Rock": 14, "Steel": 15, "Water": 16 } pokemon_types = [ "Bug", "Dark", "Dragon", "Electric", "Fairy", "Fighting", "Fire", "Ghost", "Grass", "Ground", "Ice", "Normal", "Poison", "Psychic", "Rock", "Steel", "Water" ] # Load train images for pokemon_type in os.listdir(TRAIN_DATA_DIR): for image_filename in os.listdir( os.path.join(TRAIN_DATA_DIR, pokemon_type)): if image_filename.endswith(IMAGE_FORMAT): image_filepath = os.path.join(TRAIN_DATA_DIR, pokemon_type, image_filename) image_ndarray = ndimage.imread(image_filepath, mode="RGB") train_dataset[index] = image_ndarray train_labels[index] = pokemon_type_id_map.get(pokemon_type) index += 1 index = 0 # Load test image for pokemon_type in os.listdir(TEST_DATA_DIR): for image_filename in os.listdir( os.path.join(TEST_DATA_DIR, pokemon_type)): if image_filename.endswith(IMAGE_FORMAT): image_filepath = os.path.join(TEST_DATA_DIR, pokemon_type, image_filename) image_ndarray = ndimage.imread(image_filepath, mode="RGB") test_dataset[index] = image_ndarray test_labels[index] = pokemon_type_id_map.get(pokemon_type) index += 1 # Define the model keys_placeholder = tf.placeholder(tf.int32, shape=[None, 1]) keys = tf.identity(keys_placeholder) model_base64_placeholder = tf.placeholder(shape=[None], dtype=tf.string, name="model_input_b64_images") model_base64_string = tf.decode_base64(model_base64_placeholder) model_base64_input = tf.map_fn(lambda x: tf.image.resize_images( tf.image.decode_jpeg(x, channels=RGB_CHANNEL_SIZE), [IMAGE_SIZE, IMAGE_SIZE]), model_base64_string, dtype=tf.float32) x = tf.placeholder(tf.float32, shape=(None, IMAGE_SIZE, IMAGE_SIZE, RGB_CHANNEL_SIZE)) y = tf.placeholder(tf.int32, shape=(None, )) batch_size = FLAGS.batch_size epoch_number = FLAGS.epoch_number checkpoint_dir = FLAGS.checkpoint_dir if not os.path.exists(checkpoint_dir): os.makedirs(checkpoint_dir) tensorboard_dir = FLAGS.tensorboard_dir mode = FLAGS.mode checkpoint_file = checkpoint_dir + "/checkpoint.ckpt" steps_to_validate = FLAGS.steps_to_validate def cnn_inference(x): # Convolution layer result: [BATCH_SIZE, 16, 16, 64] with tf.variable_scope("conv1"): weights = tf.get_variable( "weights", [3, 3, 3, 32], initializer=tf.random_normal_initializer()) bias = tf.get_variable("bias", [32], initializer=tf.random_normal_initializer()) layer = tf.nn.conv2d(x, weights, strides=[1, 1, 1, 1], padding="SAME") layer = tf.nn.bias_add(layer, bias) layer = tf.nn.relu(layer) layer = tf.nn.max_pool(layer, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="SAME") # Convolution layer result: [BATCH_SIZE, 8, 8, 64] with tf.variable_scope("conv2"): weights = tf.get_variable( "weights", [3, 3, 32, 64], initializer=tf.random_normal_initializer()) bias = tf.get_variable("bias", [64], initializer=tf.random_normal_initializer()) layer = tf.nn.conv2d(layer, weights, strides=[1, 1, 1, 1], padding="SAME") layer = tf.nn.bias_add(layer, bias) layer = tf.nn.relu(layer) layer = tf.nn.max_pool(layer, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="SAME") # Reshape for full-connect network layer = tf.reshape(layer, [-1, 8 * 8 * 64]) # Full connected layer result: [BATCH_SIZE, 17] with tf.variable_scope("fc1"): # weights.get_shape().as_list()[0]] = 8 * 8 * 64 weights = tf.get_variable( "weights", [8 * 8 * 64, LABEL_SIZE], initializer=tf.random_normal_initializer()) bias = tf.get_variable("bias", [LABEL_SIZE], initializer=tf.random_normal_initializer()) layer = tf.add(tf.matmul(layer, weights), bias) return layer def lstm_inference(x): RNN_HIDDEN_UNITS = 128 # x was [BATCH_SIZE, 32, 32, 3] # x changes to [32, BATCH_SIZE, 32, 3] x = tf.transpose(x, [1, 0, 2, 3]) # x changes to [32 * BATCH_SIZE, 32 * 3] x = tf.reshape(x, [-1, IMAGE_SIZE * RGB_CHANNEL_SIZE]) # x changes to array of 32 * [BATCH_SIZE, 32 * 3] x = tf.split(axis=0, num_or_size_splits=IMAGE_SIZE, value=x) weights = tf.Variable(tf.random_normal([RNN_HIDDEN_UNITS, LABEL_SIZE])) biases = tf.Variable(tf.random_normal([LABEL_SIZE])) # output size is 128, state size is (c=128, h=128) lstm_cell = rnn.BasicLSTMCell(RNN_HIDDEN_UNITS, forget_bias=1.0) # outputs is array of 32 * [BATCH_SIZE, 128] #outputs, states = rnn.rnn(lstm_cell, x, dtype=tf.float32) outputs, states = rnn.static_rnn(lstm_cell, x, dtype=tf.float32) # outputs[-1] is [BATCH_SIZE, 128] return tf.matmul(outputs[-1], weights) + biases def bidirectional_lstm_inference(x): RNN_HIDDEN_UNITS = 128 # x was [BATCH_SIZE, 32, 32, 3] # x changes to [32, BATCH_SIZE, 32, 3] x = tf.transpose(x, [1, 0, 2, 3]) # x changes to [32 * BATCH_SIZE, 32 * 3] x = tf.reshape(x, [-1, IMAGE_SIZE * RGB_CHANNEL_SIZE]) # x changes to array of 32 * [BATCH_SIZE, 32 * 3] x = tf.split(axis=0, num_or_size_splits=IMAGE_SIZE, value=x) weights = tf.Variable( tf.random_normal([2 * RNN_HIDDEN_UNITS, LABEL_SIZE])) biases = tf.Variable(tf.random_normal([LABEL_SIZE])) # output size is 128, state size is (c=128, h=128) fw_lstm_cell = rnn.BasicLSTMCell(RNN_HIDDEN_UNITS, forget_bias=1.0) bw_lstm_cell = rnn.BasicLSTMCell(RNN_HIDDEN_UNITS, forget_bias=1.0) # outputs is array of 32 * [BATCH_SIZE, 128] #outputs, _, _ = rnn.bidirectional_rnn( # fw_lstm_cell, bw_lstm_cell, x, dtype=tf.float32) outputs, _, _ = tf.nn.static_bidirectional_rnn(fw_lstm_cell, bw_lstm_cell, x, dtype=tf.float32) # outputs[-1] is [BATCH_SIZE, 128] return tf.matmul(outputs[-1], weights) + biases def stacked_lstm_inference(x): RNN_HIDDEN_UNITS = 128 # x was [BATCH_SIZE, 32, 32, 3] # x changes to [32, BATCH_SIZE, 32, 3] x = tf.transpose(x, [1, 0, 2, 3]) # x changes to [32 * BATCH_SIZE, 32 * 3] x = tf.reshape(x, [-1, IMAGE_SIZE * RGB_CHANNEL_SIZE]) # x changes to array of 32 * [BATCH_SIZE, 32 * 3] x = tf.split(axis=0, num_or_size_splits=IMAGE_SIZE, value=x) weights = tf.Variable(tf.random_normal([RNN_HIDDEN_UNITS, LABEL_SIZE])) biases = tf.Variable(tf.random_normal([LABEL_SIZE])) # output size is 128, state size is (c=128, h=128) lstm_cell = rnn.BasicLSTMCell(RNN_HIDDEN_UNITS, forget_bias=1.0) lstm_cells = rnn.MultiRNNCell([lstm_cell] * 2) # outputs is array of 32 * [BATCH_SIZE, 128] outputs, states = rnn.rnn(lstm_cells, x, dtype=tf.float32) # outputs[-1] is [BATCH_SIZE, 128] return tf.matmul(outputs[-1], weights) + biases def inference(inputs): print("Use the model: {}".format(FLAGS.model)) if FLAGS.model == "cnn": return cnn_inference(inputs) elif FLAGS.model == "lstm": return lstm_inference(inputs) elif FLAGS.model == "bidirectional_lstm": return bidirectional_lstm_inference(inputs) elif FLAGS.model == "stacked_lstm": return stacked_lstm_inference(inputs) else: print("Unknow model, exit now") exit(1) # Define train op logit = inference(x) loss = tf.reduce_mean( tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logit, labels=y)) learning_rate = FLAGS.learning_rate print("Use the optimizer: {}".format(FLAGS.optimizer)) if FLAGS.optimizer == "sgd": optimizer = tf.train.GradientDescentOptimizer(learning_rate) elif FLAGS.optimizer == "adadelta": optimizer = tf.train.AdadeltaOptimizer(learning_rate) elif FLAGS.optimizer == "adagrad": optimizer = tf.train.AdagradOptimizer(learning_rate) elif FLAGS.optimizer == "adam": optimizer = tf.train.AdamOptimizer(learning_rate) elif FLAGS.optimizer == "ftrl": optimizer = tf.train.FtrlOptimizer(learning_rate) elif FLAGS.optimizer == "rmsprop": optimizer = tf.train.RMSPropOptimizer(learning_rate) else: print("Unknow optimizer: {}, exit now".format(FLAGS.optimizer)) exit(1) global_step = tf.Variable(0, name='global_step', trainable=False) train_op = optimizer.minimize(loss, global_step=global_step) # Define accuracy and inference op tf.get_variable_scope().reuse_variables() #logits = inference(x) inference_logits = inference(model_base64_input) inference_predict_softmax = tf.nn.softmax(inference_logits) inference_predict_op = tf.argmax(inference_predict_softmax, 1) inference_correct_prediction = tf.equal(inference_predict_op, tf.to_int64(y)) inference_accuracy_op = tf.reduce_mean( tf.cast(inference_correct_prediction, tf.float32)) model_signature = signature_def_utils.build_signature_def( inputs={"images": utils.build_tensor_info(model_base64_placeholder)}, outputs={ "softmax": utils.build_tensor_info(inference_predict_softmax), "prediction": utils.build_tensor_info(inference_predict_op) }, method_name=signature_constants.PREDICT_METHOD_NAME) saver = tf.train.Saver() tf.summary.scalar('loss', loss) init_op = tf.global_variables_initializer() # Create session to run graph with tf.Session() as sess: summary_op = tf.summary.merge_all() writer = tf.summary.FileWriter(tensorboard_dir, sess.graph) sess.run(init_op) if mode == "train": ckpt = tf.train.get_checkpoint_state(checkpoint_dir) if ckpt and ckpt.model_checkpoint_path: logging.info("Continue training from the model {}".format( ckpt.model_checkpoint_path)) saver.restore(sess, ckpt.model_checkpoint_path) #start_time = datetime.datetime.now() for epoch in range(epoch_number): _, loss_value, step = sess.run([train_op, loss, global_step], feed_dict={ x: train_dataset, y: train_labels }) if epoch % steps_to_validate == 0: end_time = datetime.datetime.now() """ train_accuracy_value, summary_value = sess.run( [accuracy_op, summary_op], feed_dict={x: train_dataset, y: train_labels}) test_accuracy_value = sess.run( accuracy_op, feed_dict={x: test_dataset, y: test_labels}) logging.info( "[{}] Epoch: {}, loss: {}, train_accuracy: {}, test_accuracy: {}". format(end_time - start_time, epoch, loss_value, train_accuracy_value, test_accuracy_value)) """ logging.info("Epoch: {}, loss: {}".format( epoch, loss_value)) saver.save(sess, checkpoint_file, global_step=step) #writer.add_summary(summary_value, step) #start_time = end_time # Export the model export_path = os.path.join( compat.as_bytes(FLAGS.model_path), compat.as_bytes(str(FLAGS.model_version))) logging.info("Export the model to {}".format(export_path)) try: legacy_init_op = tf.group(tf.tables_initializer(), name='legacy_init_op') builder = saved_model_builder.SavedModelBuilder(export_path) builder.add_meta_graph_and_variables( sess, [tag_constants.SERVING], clear_devices=True, signature_def_map={ signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY: model_signature, }, legacy_init_op=legacy_init_op) builder.save() except Exception as e: logging.error( "Fail to export saved model, exception: {}".format(e)) """ logging.info("Exporting trained model to {}".format(FLAGS.model_path)) model_exporter = exporter.Exporter(saver) model_exporter.init( sess.graph.as_graph_def(), named_graph_signatures={ 'inputs': exporter.generic_signature({ "keys": keys_placeholder, "features": x }), 'outputs': exporter.generic_signature({ "keys": keys, "prediction": predict_op }) }) model_exporter.export(FLAGS.model_path, tf.constant(FLAGS.export_version), sess) logging.info("Done export model: {}".format(FLAGS.model_path)) """ elif mode == "inference": ckpt = tf.train.get_checkpoint_state(checkpoint_dir) if ckpt and ckpt.model_checkpoint_path: logging.info("Load the model {}".format( ckpt.model_checkpoint_path)) saver.restore(sess, ckpt.model_checkpoint_path) start_time = datetime.datetime.now() image_ndarray = ndimage.imread(FLAGS.image, mode="RGB") # TODO: Update for server without gui #print_image(image_ndarray) image_ndarray = image_ndarray.reshape(1, IMAGE_SIZE, IMAGE_SIZE, RGB_CHANNEL_SIZE) prediction = sess.run(predict_op, feed_dict={x: image_ndarray}) end_time = datetime.datetime.now() pokemon_type = pokemon_types[prediction[0]] logging.info("[{}] Predict type: {}".format( end_time - start_time, pokemon_type)) elif FLAGS.mode == "savedmodel": if restore_from_checkpoint(sess, saver, LATEST_CHECKPOINT) == False: logging.error("No checkpoint for exporting model, exit now") exit(1) export_path = os.path.join( compat.as_bytes(FLAGS.model_path), compat.as_bytes(str(FLAGS.model_version))) logging.info("Export the model to {}".format(export_path)) try: legacy_init_op = tf.group(tf.tables_initializer(), name='legacy_init_op') builder = saved_model_builder.SavedModelBuilder(export_path) builder.add_meta_graph_and_variables( sess, [tag_constants.SERVING], clear_devices=True, signature_def_map={ signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY: model_signature, }, legacy_init_op=legacy_init_op) builder.save() except Exception as e: logging.error( "Fail to export saved model, exception: {}".format(e))
def base64_to_tensor_image(websafe_base64): return tf.image.decode_image(tf.decode_base64(websafe_base64))
import tensorflow as tf import base64 f = open("/Users/xingoo/PycharmProjects/ai/test/3.jpg", 'rb') file_content = f.read() base64str = str(base64.urlsafe_b64encode(file_content), encoding='utf-8') input_tensor = tf.convert_to_tensor(base64str, dtype=tf.string) image_str = tf.decode_base64(input_tensor) img = tf.image.decode_image(image_str, channels=3) with tf.Session() as sess: print(sess.run(image_str)) print(sess.run(img))
print('accuracy: {0}'.format(score)) K.set_learning_phase(0) # test sess = K.get_session() from tensorflow.python.framework import graph_util # Make GraphDef of Transfer Model g_trans = sess.graph g_trans_def = graph_util.convert_variables_to_constants( sess, g_trans.as_graph_def(), [model.output.name.replace(':0', '')]) # Image Converter Model with tf.Graph().as_default() as g_input: input_b64 = tf.placeholder(shape=(1, ), dtype=tf.string, name='input') input_bytes = tf.decode_base64(input_b64[0]) image = tf.image.decode_image(input_bytes) image_f = tf.image.convert_image_dtype(image, dtype=tf.float32) input_image = tf.expand_dims(image_f, 0) output = tf.identity(input_image, name='input_image') g_input_def = g_input.as_graph_def() with tf.Graph().as_default() as g_combined: x = tf.placeholder(tf.string, name="input_b64") im, = tf.import_graph_def(g_input_def, input_map={'input:0': x}, return_elements=["input_image:0"]) pred, = tf.import_graph_def(
def decode_and_process(base64): _bytes = tf.decode_base64(base64) _image = self.__tf_jpeg_process(_bytes) return _image
def main(): if tf.__version__.split('.')[0] != "1": raise Exception("Tensorflow version 1 required") if a.seed is None: a.seed = random.randint(0, 2**31 - 1) tf.set_random_seed(a.seed) np.random.seed(a.seed) random.seed(a.seed) if not os.path.exists(a.output_dir): os.makedirs(a.output_dir) if a.mode == "test" or a.mode == "export": if a.checkpoint is None: raise Exception("checkpoint required for test mode") # load some options from the checkpoint options = {"which_direction", "ngf", "ndf", "lab_colorization"} with open(os.path.join(a.checkpoint, "options.json")) as f: for key, val in json.loads(f.read()).items(): if key in options: print("loaded", key, "=", val) setattr(a, key, val) # disable these features in test mode a.scale_size = CROP_SIZE a.flip = False for k, v in a._get_kwargs(): print(k, "=", v) with open(os.path.join(a.output_dir, "options.json"), "w") as f: f.write(json.dumps(vars(a), sort_keys=True, indent=4)) if a.mode == "export": # export the generator to a meta graph that can be imported later for standalone generation if a.lab_colorization: raise Exception("export not supported for lab_colorization") input = tf.placeholder(tf.string, shape=[1]) input_data = tf.decode_base64(input[0]) input_image = tf.image.decode_png(input_data) # remove alpha channel if present input_image = tf.cond(tf.equal(tf.shape(input_image)[2], 4), lambda: input_image[:,:,:3], lambda: input_image) # convert grayscale to RGB input_image = tf.cond(tf.equal(tf.shape(input_image)[2], 1), lambda: tf.image.grayscale_to_rgb(input_image), lambda: input_image) input_image = tf.image.convert_image_dtype(input_image, dtype=tf.float32) input_image.set_shape([CROP_SIZE, CROP_SIZE, 3]) batch_input = tf.expand_dims(input_image, axis=0) with tf.variable_scope("generator"): batch_output = deprocess(create_generator(preprocess(batch_input), 3)) output_image = tf.image.convert_image_dtype(batch_output, dtype=tf.uint8)[0] if a.output_filetype == "png": output_data = tf.image.encode_png(output_image) elif a.output_filetype == "jpeg": output_data = tf.image.encode_jpeg(output_image, quality=80) else: raise Exception("invalid filetype") output = tf.convert_to_tensor([tf.encode_base64(output_data)]) key = tf.placeholder(tf.string, shape=[1]) inputs = { "key": key.name, "input": input.name } tf.add_to_collection("inputs", json.dumps(inputs)) outputs = { "key": tf.identity(key).name, "output": output.name, } tf.add_to_collection("outputs", json.dumps(outputs)) init_op = tf.global_variables_initializer() restore_saver = tf.train.Saver() export_saver = tf.train.Saver() with tf.Session() as sess: sess.run(init_op) print("loading model from checkpoint") checkpoint = tf.train.latest_checkpoint(a.checkpoint) restore_saver.restore(sess, checkpoint) print("exporting model") export_saver.export_meta_graph(filename=os.path.join(a.output_dir, "export.meta")) export_saver.save(sess, os.path.join(a.output_dir, "export"), write_meta_graph=False) return examples = load_examples() print("examples count = %d" % examples.count) # inputs and targets are [batch_size, height, width, channels] model = create_model(examples.inputs, examples.targets) # undo colorization splitting on images that we use for display/output if a.lab_colorization: if a.which_direction == "AtoB": # inputs is brightness, this will be handled fine as a grayscale image # need to augment targets and outputs with brightness targets = augment(examples.targets, examples.inputs) outputs = augment(model.outputs, examples.inputs) # inputs can be deprocessed normally and handled as if they are single channel # grayscale images inputs = deprocess(examples.inputs) elif a.which_direction == "BtoA": # inputs will be color channels only, get brightness from targets inputs = augment(examples.inputs, examples.targets) targets = deprocess(examples.targets) outputs = deprocess(model.outputs) else: raise Exception("invalid direction") else: inputs = deprocess(examples.inputs) targets = deprocess(examples.targets) outputs = deprocess(model.outputs) def convert(image): if a.aspect_ratio != 1.0: # upscale to correct aspect ratio size = [CROP_SIZE, int(round(CROP_SIZE * a.aspect_ratio))] image = tf.image.resize_images(image, size=size, method=tf.image.ResizeMethod.BICUBIC) return tf.image.convert_image_dtype(image, dtype=tf.uint8, saturate=True) # reverse any processing on images so they can be written to disk or displayed to user with tf.name_scope("convert_inputs"): converted_inputs = convert(inputs) with tf.name_scope("convert_targets"): converted_targets = convert(targets) with tf.name_scope("convert_outputs"): converted_outputs = convert(outputs) with tf.name_scope("encode_images"): display_fetches = { "paths": examples.paths, "inputs": tf.map_fn(tf.image.encode_png, converted_inputs, dtype=tf.string, name="input_pngs"), "targets": tf.map_fn(tf.image.encode_png, converted_targets, dtype=tf.string, name="target_pngs"), "outputs": tf.map_fn(tf.image.encode_png, converted_outputs, dtype=tf.string, name="output_pngs"), } # summaries with tf.name_scope("inputs_summary"): tf.summary.image("inputs", converted_inputs) with tf.name_scope("targets_summary"): tf.summary.image("targets", converted_targets) with tf.name_scope("outputs_summary"): tf.summary.image("outputs", converted_outputs) with tf.name_scope("predict_real_summary"): tf.summary.image("predict_real", tf.image.convert_image_dtype(model.predict_real, dtype=tf.uint8)) with tf.name_scope("predict_fake_summary"): tf.summary.image("predict_fake", tf.image.convert_image_dtype(model.predict_fake, dtype=tf.uint8)) tf.summary.scalar("discriminator_loss", model.discrim_loss) tf.summary.scalar("generator_loss_GAN", model.gen_loss_GAN) tf.summary.scalar("generator_loss_L1", model.gen_loss_L1) for var in tf.trainable_variables(): tf.summary.histogram(var.op.name + "/values", var) for grad, var in model.discrim_grads_and_vars + model.gen_grads_and_vars: tf.summary.histogram(var.op.name + "/gradients", grad) with tf.name_scope("parameter_count"): parameter_count = tf.reduce_sum([tf.reduce_prod(tf.shape(v)) for v in tf.trainable_variables()]) saver = tf.train.Saver(max_to_keep=1) logdir = a.output_dir if (a.trace_freq > 0 or a.summary_freq > 0) else None sv = tf.train.Supervisor(logdir=logdir, save_summaries_secs=0, saver=None) with sv.managed_session() as sess: print("parameter_count =", sess.run(parameter_count)) if a.checkpoint is not None: print("loading model from checkpoint") checkpoint = tf.train.latest_checkpoint(a.checkpoint) saver.restore(sess, checkpoint) max_steps = 2**32 if a.max_epochs is not None: max_steps = examples.steps_per_epoch * a.max_epochs if a.max_steps is not None: max_steps = a.max_steps if a.mode == "test": # testing # at most, process the test data once max_steps = min(examples.steps_per_epoch, max_steps) for step in range(max_steps): results = sess.run(display_fetches) filesets = save_images(results) for i, f in enumerate(filesets): print("evaluated image", f["name"]) index_path = append_index(filesets) print("wrote index at", index_path) else: # training start = time.time() for step in range(max_steps): def should(freq): return freq > 0 and ((step + 1) % freq == 0 or step == max_steps - 1) options = None run_metadata = None if should(a.trace_freq): options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE) run_metadata = tf.RunMetadata() fetches = { "train": model.train, "global_step": sv.global_step, } if should(a.progress_freq): fetches["discrim_loss"] = model.discrim_loss fetches["gen_loss_GAN"] = model.gen_loss_GAN fetches["gen_loss_L1"] = model.gen_loss_L1 if should(a.summary_freq): fetches["summary"] = sv.summary_op if should(a.display_freq): fetches["display"] = display_fetches results = sess.run(fetches, options=options, run_metadata=run_metadata) if should(a.summary_freq): print("recording summary") sv.summary_writer.add_summary(results["summary"], results["global_step"]) if should(a.display_freq): print("saving display images") filesets = save_images(results["display"], step=results["global_step"]) append_index(filesets, step=True) if should(a.trace_freq): print("recording trace") sv.summary_writer.add_run_metadata(run_metadata, "step_%d" % results["global_step"]) if should(a.progress_freq): # global_step will have the correct step count if we resume from a checkpoint train_epoch = math.ceil(results["global_step"] / examples.steps_per_epoch) train_step = (results["global_step"] - 1) % examples.steps_per_epoch + 1 rate = (step + 1) * a.batch_size / (time.time() - start) remaining = (max_steps - step) * a.batch_size / rate print("progress epoch %d step %d image/sec %0.1f remaining %dm" % (train_epoch, train_step, rate, remaining / 60)) print("discrim_loss", results["discrim_loss"]) print("gen_loss_GAN", results["gen_loss_GAN"]) print("gen_loss_L1", results["gen_loss_L1"]) if should(a.save_freq): print("saving model") saver.save(sess, os.path.join(a.output_dir, "model"), global_step=sv.global_step) if sv.should_stop(): break
def handle(): image_data = tf.decode_base64(request.data) array = tf.image.decode_jpeg(image_data) pp.pprint(array) return match(array)
def batch_base64_to_tensor(input_text): img = tf.map_fn(tf.image.decode_image, tf.decode_base64(input_text), dtype=tf.uint8) return img
def main(): if a.seed is None: a.seed = random.randint(0, 2**31 - 1) tf.set_random_seed(a.seed) np.random.seed(a.seed) random.seed(a.seed) if not os.path.exists(a.output_dir): os.makedirs(a.output_dir) if a.mode == "test" or a.mode == "export": if a.checkpoint is None: raise Exception("checkpoint required for test mode") # load some options from the checkpoint options = {"which_direction", "ngf", "ndf", "lab_colorization"} with open(os.path.join(a.checkpoint, "options.json")) as f: for key, val in json.loads(f.read()).items(): if key in options: print("loaded", key, "=", val) setattr(a, key, val) # disable these features in test mode a.scale_size = CROP_SIZE a.flip = False for k, v in a._get_kwargs(): print(k, "=", v) with open(os.path.join(a.output_dir, "options.json"), "w") as f: f.write(json.dumps(vars(a), sort_keys=True, indent=4)) if a.mode == "export": # export the generator to a meta graph that can be imported later for standalone generation if a.lab_colorization: raise Exception("export not supported for lab_colorization") input = tf.placeholder(tf.string, shape=[1]) input_data = tf.decode_base64(input[0]) input_image = tf.image.decode_png(input_data) # remove alpha channel if present input_image = tf.cond(tf.equal(tf.shape(input_image)[2], 4), lambda: input_image[:, :, :3], lambda: input_image) # convert grayscale to RGB input_image = tf.cond(tf.equal(tf.shape(input_image)[2], 1), lambda: tf.image.grayscale_to_rgb(input_image), lambda: input_image) input_image = tf.image.convert_image_dtype(input_image, dtype=tf.float32) input_image.set_shape([CROP_SIZE, CROP_SIZE, 3]) batch_input = tf.expand_dims(input_image, axis=0) with tf.variable_scope("generator"): batch_output = deprocess( create_generator(preprocess(batch_input), 3)) output_image = tf.image.convert_image_dtype(batch_output, dtype=tf.uint8)[0] if a.output_filetype == "png": output_data = tf.image.encode_png(output_image) elif a.output_filetype == "jpeg": output_data = tf.image.encode_jpeg(output_image, quality=80) else: raise Exception("invalid filetype") output = tf.convert_to_tensor([tf.encode_base64(output_data)]) key = tf.placeholder(tf.string, shape=[1]) inputs = {"key": key.name, "input": input.name} tf.add_to_collection("inputs", json.dumps(inputs)) outputs = { "key": tf.identity(key).name, "output": output.name, } tf.add_to_collection("outputs", json.dumps(outputs)) init_op = tf.global_variables_initializer() restore_saver = tf.train.Saver() export_saver = tf.train.Saver() with tf.Session() as sess: sess.run(init_op) print("loading model from checkpoint") checkpoint = tf.train.latest_checkpoint(a.checkpoint) restore_saver.restore(sess, checkpoint) print("exporting model") export_saver.export_meta_graph( filename=os.path.join(a.output_dir, "export.meta")) export_saver.save(sess, os.path.join(a.output_dir, "export"), write_meta_graph=False) return examples = load_examples() print("examples count = %d" % examples.count) # inputs and targets are [batch_size, height, width, channels] model = create_model(examples.inputs, examples.targets) # undo colorization splitting on images that we use for display/output if a.lab_colorization: if a.which_direction == "AtoB": # inputs is brightness, this will be handled fine as a grayscale image # need to augment targets and outputs with brightness targets = augment(examples.targets, examples.inputs) outputs = augment(model.outputs, examples.inputs) # inputs can be deprocessed normally and handled as if they are single channel # grayscale images inputs = deprocess(examples.inputs) elif a.which_direction == "BtoA": # inputs will be color channels only, get brightness from targets inputs = augment(examples.inputs, examples.targets) targets = deprocess(examples.targets) outputs = deprocess(model.outputs) else: raise Exception("invalid direction") else: inputs = deprocess(examples.inputs) targets = deprocess(examples.targets) outputs = deprocess(model.outputs) def convert(image): if a.aspect_ratio != 1.0: # upscale to correct aspect ratio size = [CROP_SIZE, int(round(CROP_SIZE * a.aspect_ratio))] image = tf.image.resize_images( image, size=size, method=tf.image.ResizeMethod.BICUBIC) return tf.image.convert_image_dtype(image, dtype=tf.uint8, saturate=True) # reverse any processing on images so they can be written to disk or displayed to user with tf.name_scope("convert_inputs"): converted_inputs = convert(inputs) with tf.name_scope("convert_targets"): converted_targets = convert(targets) with tf.name_scope("convert_outputs"): converted_outputs = convert(outputs) with tf.name_scope("encode_images"): display_fetches = { "paths": examples.paths, "inputs": tf.map_fn(tf.image.encode_png, converted_inputs, dtype=tf.string, name="input_pngs"), "targets": tf.map_fn(tf.image.encode_png, converted_targets, dtype=tf.string, name="target_pngs"), "outputs": tf.map_fn(tf.image.encode_png, converted_outputs, dtype=tf.string, name="output_pngs"), } # summaries with tf.name_scope("inputs_summary"): tf.summary.image("inputs", converted_inputs) with tf.name_scope("targets_summary"): tf.summary.image("targets", converted_targets) with tf.name_scope("outputs_summary"): tf.summary.image("outputs", converted_outputs) with tf.name_scope("predict_real_summary"): tf.summary.image( "predict_real", tf.image.convert_image_dtype(model.predict_real, dtype=tf.uint8)) with tf.name_scope("predict_fake_summary"): tf.summary.image( "predict_fake", tf.image.convert_image_dtype(model.predict_fake, dtype=tf.uint8)) tf.summary.scalar("discriminator_loss", model.discrim_loss) tf.summary.scalar("generator_loss_GAN", model.gen_loss_GAN) tf.summary.scalar("generator_loss_L1", model.gen_loss_L1) for var in tf.trainable_variables(): tf.summary.histogram(var.op.name + "/values", var) for grad, var in model.discrim_grads_and_vars + model.gen_grads_and_vars: tf.summary.histogram(var.op.name + "/gradients", grad) with tf.name_scope("parameter_count"): parameter_count = tf.reduce_sum( [tf.reduce_prod(tf.shape(v)) for v in tf.trainable_variables()]) saver = tf.train.Saver(max_to_keep=1) logdir = a.output_dir if (a.trace_freq > 0 or a.summary_freq > 0) else None sv = tf.train.Supervisor(logdir=logdir, save_summaries_secs=0, saver=None) with sv.managed_session() as sess: print("parameter_count =", sess.run(parameter_count)) if a.checkpoint is not None: print("loading model from checkpoint") checkpoint = tf.train.latest_checkpoint(a.checkpoint) saver.restore(sess, checkpoint) max_steps = 2**32 if a.max_epochs is not None: max_steps = examples.steps_per_epoch * a.max_epochs if a.max_steps is not None: max_steps = a.max_steps if a.mode == "test": # testing # at most, process the test data once start = time.time() max_steps = min(examples.steps_per_epoch, max_steps) for step in range(max_steps): results = sess.run(display_fetches) filesets = save_images(results) for i, f in enumerate(filesets): print("evaluated image", f["name"]) index_path = append_index(filesets) print("wrote index at", index_path) print("rate", (time.time() - start) / max_steps) else: # training start = time.time() for step in range(max_steps): def should(freq): return freq > 0 and ((step + 1) % freq == 0 or step == max_steps - 1) options = None run_metadata = None if should(a.trace_freq): options = tf.RunOptions( trace_level=tf.RunOptions.FULL_TRACE) run_metadata = tf.RunMetadata() fetches = { "train": model.train, "global_step": sv.global_step, } if should(a.progress_freq): fetches["discrim_loss"] = model.discrim_loss fetches["gen_loss_GAN"] = model.gen_loss_GAN fetches["gen_loss_L1"] = model.gen_loss_L1 if should(a.summary_freq): fetches["summary"] = sv.summary_op if should(a.display_freq): fetches["display"] = display_fetches results = sess.run(fetches, options=options, run_metadata=run_metadata) if should(a.summary_freq): print("recording summary") sv.summary_writer.add_summary(results["summary"], results["global_step"]) if should(a.display_freq): print("saving display images") filesets = save_images(results["display"], step=results["global_step"]) append_index(filesets, step=True) if should(a.trace_freq): print("recording trace") sv.summary_writer.add_run_metadata( run_metadata, "step_%d" % results["global_step"]) if should(a.progress_freq): # global_step will have the correct step count if we resume from a checkpoint train_epoch = math.ceil(results["global_step"] / examples.steps_per_epoch) train_step = (results["global_step"] - 1) % examples.steps_per_epoch + 1 rate = (step + 1) * a.batch_size / (time.time() - start) remaining = (max_steps - step) * a.batch_size / rate print( "progress epoch %d step %d image/sec %0.1f remaining %dm" % (train_epoch, train_step, rate, remaining / 60)) print("discrim_loss", results["discrim_loss"]) print("gen_loss_GAN", results["gen_loss_GAN"]) print("gen_loss_L1", results["gen_loss_L1"]) if should(a.save_freq): print("saving model") saver.save(sess, os.path.join(a.output_dir, "model"), global_step=sv.global_step) if sv.should_stop(): break
import tensorflow as tf from tensorflow.python.saved_model import signature_constants from tensorflow.python.saved_model import tag_constants export_dir = "modelbase64" builder = tf.saved_model.builder.SavedModelBuilder(export_dir) sigs = {} with tf.Graph().as_default() as g1: base64_str = tf.placeholder(tf.string, shape=[None], name='input_string') base64_scalar = tf.reshape(base64_str, []) input_str = tf.decode_base64(base64_scalar) decoded_image = tf.image.decode_png(input_str, channels=3) decoded_image_as_float = tf.image.convert_image_dtype( decoded_image, tf.float32) decoded_image_4d = tf.expand_dims(decoded_image_as_float, 0) resize_shape = tf.stack([224, 224]) resize_shape_as_int = tf.cast(resize_shape, dtype=tf.int32) resize_image = tf.image.resize_bilinear(decoded_image_4d, resize_shape_as_int) print(resize_image.shape) tf.identity(resize_image, name="DecodeJPGOutput") g1def = g1.as_graph_def() with tf.Graph().as_default() as g2: with tf.Session(graph=g2) as sess: tf.saved_model.loader.load(sess, ["serve"], "./saved_model") graph = tf.get_default_graph()