def main(*args, **kwargs): check_dataset() mnist = input_data.read_data_sets(flags.data_url, one_hot=True) # define the input dataset, return image and label def input_fn(run_mode, **kwargs): def gen(): while True: yield mnist.train.next_batch(flags.batch_size) ds = tf.data.Dataset.from_generator( gen, output_types=(tf.float32, tf.int64), output_shapes=(tf.TensorShape([None, 784]), tf.TensorShape([None, 10]))) return ds.make_one_shot_iterator().get_next() # define the model for training or evaling. def model_fn(inputs, run_mode, **kwargs): x, y_ = inputs y = tf.keras.layers.Dense(128, activation='relu')(x) y = tf.keras.layers.Dense(10)(y) cross_entropy = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y)) correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) export_spec = mox.ExportSpec(inputs_dict={'images': x}, outputs_dict={'logits': y}, version='model') return mox.ModelSpec(loss=cross_entropy, log_info={ 'loss': cross_entropy, 'accuracy': accuracy }, export_spec=export_spec) mox.run(input_fn=input_fn, model_fn=model_fn, optimizer_fn=mox.get_optimizer_fn('adam', learning_rate=0.01), run_mode=mox.ModeKeys.TRAIN, batch_size=flags.batch_size, auto_batch=False, log_dir=flags.train_url, max_number_of_steps=1000, log_every_n_steps=10, export_model=mox.ExportKeys.TF_SERVING)
def main(*args): mnist = input_data.read_data_sets(flags.data_url, one_hot=True) # define the input dataset, return image and label def input_fn(run_mode, **kwargs): def gen(): while True: yield mnist.train.next_batch(50) ds = tf.data.Dataset.from_generator( gen, output_types=(tf.float32, tf.int64), output_shapes=(tf.TensorShape([None, 784]), tf.TensorShape([None, 10]))) return ds.make_one_shot_iterator().get_next() # define the model for training or evaling. def model_fn(inputs, run_mode, **kwargs): x, y_ = inputs W = tf.get_variable(name='W', initializer=tf.zeros([784, 10])) b = tf.get_variable(name='b', initializer=tf.zeros([10])) y = tf.matmul(x, W) + b cross_entropy = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y)) predictions = tf.argmax(y, 1) correct_predictions = tf.equal(predictions, tf.argmax(y_, 1)) accuracy = tf.reduce_mean(tf.cast(correct_predictions, tf.float32)) export_spec = mox.ExportSpec(inputs_dict={'images': x}, outputs_dict={'predictions': predictions}, version='model') return mox.ModelSpec(loss=cross_entropy, log_info={ 'loss': cross_entropy, 'accuracy': accuracy }, export_spec=export_spec) mox.run(input_fn=input_fn, model_fn=model_fn, optimizer_fn=mox.get_optimizer_fn('sgd', learning_rate=0.01), run_mode=mox.ModeKeys.TRAIN, batch_size=50, auto_batch=False, log_dir=flags.train_url, max_number_of_steps=1000, log_every_n_steps=10, export_model=mox.ExportKeys.TF_SERVING)
def main(*args): num_gpus = mox.get_flag('num_gpus') num_workers = len(mox.get_flag('worker_hosts').split(',')) steps_per_epoch = int( round( math.ceil( float(NUM_SAMPLES_TRAIN) / (flags.batch_size * num_gpus * num_workers)))) if flags.is_training: mox.run(input_fn=input_fn, model_fn=model_fn, optimizer_fn=mox.get_optimizer_fn(name='adam', learning_rate=0.001), run_mode=mox.ModeKeys.TRAIN, batch_size=flags.batch_size, log_dir=flags.train_url, max_number_of_steps=steps_per_epoch * 150, log_every_n_steps=20, save_summary_steps=50, save_model_secs=120, export_model=mox.ExportKeys.TF_SERVING) else: mox.run(input_fn=input_fn, model_fn=model_fn, run_mode=mox.ModeKeys.EVAL, batch_size=5, log_every_n_steps=1, max_number_of_steps=int(NUM_SAMPLES_EVAL / 5), checkpoint_path=flags.train_url) mox.run(input_fn=input_fn, output_fn=output_fn, model_fn=model_fn, run_mode=mox.ModeKeys.PREDICT, batch_size=24, max_number_of_steps=int(NUM_SAMPLES_TEST / 24), log_every_n_steps=50, output_every_n_steps=int(NUM_SAMPLES_TEST / 24), checkpoint_path=flags.train_url) # Write results to file. tf.gfile allow writing file to EBS/s3 submission_file = os.path.join(flags.train_url, 'submission.csv') result = submission.to_csv(path_or_buf=None, index=False) with tf.gfile.Open(submission_file, 'w') as f: f.write(result)
x, y_ = inputs W = tf.get_variable(name='W', initializer=tf.zeros([784, 10])) b = tf.get_variable(name='b', initializer=tf.zeros([10])) y = tf.matmul(x, W) + b cross_entropy = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y)) predictions = tf.argmax(y, 1) correct_predictions = tf.equal(predictions, tf.argmax(y_, 1)) accuracy = tf.reduce_mean(tf.cast(correct_predictions, tf.float32)) export_spec = mox.ExportSpec(inputs_dict={'images': x}, outputs_dict={'predictions': predictions}) return mox.ModelSpec(loss=cross_entropy, log_info={ 'loss': cross_entropy, 'accuracy': accuracy }, export_spec=export_spec) if __name__ == '__main__': mox.run(input_fn=input_fn, model_fn=model_fn, optimizer_fn=mox.get_optimizer_fn('sgd', learning_rate=0.01), run_mode=mox.ModeKeys.TRAIN, batch_size=50, auto_batch=False, log_dir=flags.train_url, max_number_of_steps=1000, log_every_n_steps=10, export_model=mox.ExportKeys.TF_SERVING)
def main(*args): _data_url = flags.data_url _train_url = flags.train_url if not mox.file.is_directory(_train_url): mox.file.make_dirs(_train_url) mox.file.make_dirs('/cache/data_url') mox.file.make_dirs('/cache/train_url') mox.file.copy_parallel(_data_url, '/cache/data_url') mox.file.copy_parallel(_train_url, '/cache/train_url') flags.data_url = '/cache/data_url' flags.train_url = '/cache/train_url' atexit.register( lambda: mox.file.copy_parallel('/cache/train_url', _train_url)) logger = logging.getLogger() while logger.handlers: logger.handlers.pop() num_gpus = mox.get_flag('num_gpus') num_workers = len(mox.get_flag('worker_hosts').split(',')) steps_per_epoch = int( math.ceil( float(NUM_SAMPLES_TRAIN) / (flags.batch_size * num_gpus * num_workers))) submission = pd.DataFrame(columns=['id', 'is_iceberg']) def input_fn(run_mode, **kwargs): if run_mode == mox.ModeKeys.TRAIN: num_samples = NUM_SAMPLES_TRAIN num_epochs = None shuffle = True file_pattern = 'iceberg-train-*.tfrecord' else: num_epochs = 1 shuffle = False if run_mode == mox.ModeKeys.EVAL: num_samples = NUM_SAMPLES_EVAL file_pattern = 'iceberg-eval-*.tfrecord' else: num_samples = NUM_SAMPLES_TEST file_pattern = 'iceberg-test-*.tfrecord' keys_to_features = { 'band_1': tf.FixedLenFeature((75 * 75, ), tf.float32, default_value=None), 'band_2': tf.FixedLenFeature((75 * 75, ), tf.float32, default_value=None), 'angle': tf.FixedLenFeature([1], tf.float32, default_value=None), } items_to_handlers = { 'band_1': slim.tfexample_decoder.Tensor('band_1', shape=[75, 75]), 'band_2': slim.tfexample_decoder.Tensor('band_2', shape=[75, 75]), 'angle': slim.tfexample_decoder.Tensor('angle', shape=[]) } if run_mode == mox.ModeKeys.PREDICT: keys_to_features['id'] = tf.FixedLenFeature([1], tf.string, default_value=None) items_to_handlers['id'] = slim.tfexample_decoder.Tensor('id', shape=[]) else: keys_to_features['label'] = tf.FixedLenFeature([1], tf.int64, default_value=None) items_to_handlers['label'] = slim.tfexample_decoder.Tensor( 'label', shape=[]) dataset = mox.get_tfrecord(dataset_dir=flags.data_url, file_pattern=file_pattern, num_samples=num_samples, keys_to_features=keys_to_features, items_to_handlers=items_to_handlers, num_epochs=num_epochs, shuffle=shuffle) if run_mode == mox.ModeKeys.PREDICT: band_1, band_2, id_or_label, angle = dataset.get( ['band_1', 'band_2', 'id', 'angle']) # Non-DMA safe string cannot tensor may not be copied to a GPU. # So we encode string to a list of integer. id_or_label = tf.py_func( lambda str: np.array([ord(ch) for ch in str]), [id_or_label], tf.int64) # We know `id` is a string of 8 alphabets. id_or_label = tf.reshape(id_or_label, shape=(8, )) else: band_1, band_2, id_or_label, angle = dataset.get( ['band_1', 'band_2', 'label', 'angle']) band_3 = band_1 + band_2 # Rescale the input image to [0, 1] def rescale(*args): ret_images = [] for image in args: image = tf.cast(image, tf.float32) image_min = tf.reduce_min(image) image_max = tf.reduce_max(image) image = (image - image_min) / (image_max - image_min) ret_images.append(image) return ret_images band_1, band_2, band_3 = rescale(band_1, band_2, band_3) image = tf.stack([band_1, band_2, band_3], axis=2) # Data augementation if run_mode == mox.ModeKeys.TRAIN: image = tf.image.random_flip_left_right(image) image = tf.image.random_flip_up_down(image) image = tf.image.rot90(image, k=tf.random_uniform(shape=(), maxval=3, minval=0, dtype=tf.int32)) return image, id_or_label, angle def model_v1(images, angles, run_mode): is_training = (run_mode == mox.ModeKeys.TRAIN) # Conv Layer 1 x = Conv2D(64, kernel_size=(3, 3), activation='relu', input_shape=(75, 75, 3))(images) x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(x) x = Dropout(0.2)(x, training=is_training) # Conv Layer 2 x = Conv2D(128, kernel_size=(3, 3), activation='relu')(x) x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2))(x) x = Dropout(0.2)(x, training=is_training) # Conv Layer 3 x = Conv2D(128, kernel_size=(3, 3), activation='relu')(x) x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2))(x) x = Dropout(0.2)(x, training=is_training) # Conv Layer 4 x = Conv2D(64, kernel_size=(3, 3), activation='relu')(x) x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2))(x) x = Dropout(0.2)(x, training=is_training) # Flatten the data for upcoming dense layers x = Flatten()(x) x = Concatenate()([x, angles]) # Dense Layers x = Dense(512)(x) x = Activation('relu')(x) x = Dropout(0.2)(x, training=is_training) # Dense Layer 2 x = Dense(256)(x) x = Activation('relu')(x) x = Dropout(0.2)(x, training=is_training) # Sigmoid Layer logits = Dense(2)(x) return logits def model_fn(inputs, run_mode, **kwargs): # In train or eval, id_or_labels represents labels. In predict, id_or_labels represents id. images, id_or_labels, angles = inputs # Reshape angles from [batch_size] to [batch_size, 1] angles = tf.expand_dims(angles, 1) # Apply your version of model logits = model_v1(images, angles, run_mode) if run_mode == mox.ModeKeys.PREDICT: logits = tf.nn.softmax(logits) # clip logits to get lower loss value. logits = tf.clip_by_value(logits, clip_value_min=0.05, clip_value_max=0.95) model_spec = mox.ModelSpec(output_info={ 'id': id_or_labels, 'logits': logits }) else: labels_one_hot = slim.one_hot_encoding(id_or_labels, 2) loss = tf.losses.softmax_cross_entropy( logits=logits, onehot_labels=labels_one_hot, label_smoothing=0.0, weights=1.0) model_spec = mox.ModelSpec(loss=loss, log_info={'loss': loss}) return model_spec def output_fn(outputs): global submission for output in outputs: for id, logits in zip(output['id'], output['logits']): # Decode id from integer list to string. id = ''.join([chr(ch) for ch in id]) # Get the probability of label==1 is_iceberg = logits[1] df = pd.DataFrame([[id, is_iceberg]], columns=['id', 'is_iceberg']) submission = submission.append(df) if flags.is_training: mox.run(input_fn=input_fn, model_fn=model_fn, optimizer_fn=mox.get_optimizer_fn(name='adam', learning_rate=0.001), run_mode=mox.ModeKeys.TRAIN, batch_size=flags.batch_size, log_dir=flags.train_url, max_number_of_steps=steps_per_epoch * 150, log_every_n_steps=20, save_summary_steps=50, save_model_secs=120) else: mox.run(input_fn=input_fn, model_fn=model_fn, run_mode=mox.ModeKeys.EVAL, batch_size=5, log_every_n_steps=1, max_number_of_steps=int(NUM_SAMPLES_EVAL / 5), checkpoint_path=flags.train_url) mox.run(input_fn=input_fn, output_fn=output_fn, model_fn=model_fn, run_mode=mox.ModeKeys.PREDICT, batch_size=24, max_number_of_steps=int(NUM_SAMPLES_TEST / 24), log_every_n_steps=50, output_every_n_steps=int(NUM_SAMPLES_TEST / 24), checkpoint_path=flags.train_url) # Write results to file. tf.gfile allow writing file to EBS/s3 submission_file = os.path.join(flags.train_url, 'submission.csv') result = submission.to_csv(path_or_buf=None, index=False) with tf.gfile.Open(submission_file, 'w') as f: f.write(result)
global submission for output in outputs: for id, logits in zip(output['id'], output['logits']): # Decode id from integer list to string. id = ''.join([chr(ch) for ch in id]) # Get the probability of label==1 is_iceberg = logits[1] df = pd.DataFrame([[id, is_iceberg]], columns=['id', 'is_iceberg']) submission = submission.append(df) if __name__ == '__main__': if flags.is_training: mox.run(input_fn=input_fn, model_fn=model_fn, optimizer_fn=mox.get_optimizer_fn(name='adam', learning_rate=0.001), run_mode=mox.ModeKeys.TRAIN, batch_size=flags.batch_size, log_dir=flags.train_url, max_number_of_steps=steps_per_epoch * 150, log_every_n_steps=20, save_summary_steps=50, save_model_secs=120) else: mox.run(input_fn=input_fn, model_fn=model_fn, run_mode=mox.ModeKeys.EVAL, batch_size=5, log_every_n_steps=1, max_number_of_steps=int(NUM_SAMPLES_EVAL / 5), checkpoint_path=flags.train_url)
gen, output_types=(tf.float32, tf.int64), output_shapes=(tf.TensorShape([None, 784]), tf.TensorShape([None, 10]))) return ds.make_one_shot_iterator().get_next() def model_fn(inputs, run_mode, **kwargs): x, y_ = inputs W = tf.get_variable(name='W', initializer=tf.zeros([784, 10])) b = tf.get_variable(name='b', initializer=tf.zeros([10])) y = tf.matmul(x, W) + b cross_entropy = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y)) predictions = tf.argmax(y, 1) correct_predictions = tf.equal(predictions, tf.argmax(y_, 1)) accuracy = tf.reduce_mean(tf.cast(correct_predictions, tf.float32)) export_spec = mox.ExportSpec(inputs_dict={'images': x}, outputs_dict={'predictions': predictions}) return mox.ModelSpec(loss=cross_entropy, log_info={'loss': cross_entropy, 'accuracy': accuracy}, export_spec=export_spec) if __name__ == '__main__': mox.run(input_fn=input_fn, model_fn=model_fn, optimizer_fn=mox.get_optimizer_fn('sgd', learning_rate=0.01), run_mode=mox.ModeKeys.TRAIN, batch_size=50, auto_batch=False, log_dir=flags.train_url, max_number_of_steps=1000, log_every_n_steps=10, export_model=mox.ExportKeys.TF_SERVING)
return model_spec def output_fn(outputs): global submission for output in outputs: for id, logits in zip(output['id'], output['logits']): # Decode id from integer list to string. id = ''.join([chr(ch) for ch in id]) # Get the probability of label==1 is_iceberg = logits[1] df = pd.DataFrame([[id, is_iceberg]], columns=['id', 'is_iceberg']) submission = submission.append(df) if __name__ == '__main__': if flags.is_training: mox.run(input_fn=input_fn, model_fn=model_fn, optimizer_fn=mox.get_optimizer_fn(name='adam', learning_rate=0.001), run_mode=mox.ModeKeys.TRAIN, batch_size=flags.batch_size, log_dir=flags.log_dir, max_number_of_steps=steps_per_epoch * 150, log_every_n_steps=20, save_summary_steps=50, save_model_secs=120) else: mox.run(input_fn=input_fn, model_fn=model_fn, run_mode=mox.ModeKeys.EVAL, batch_size=5, log_every_n_steps=1, max_number_of_steps=int(NUM_SAMPLES_EVAL / 5), checkpoint_path=flags.log_dir)