self.feed_vars = [input, index] self.fetch_vars = [result] if backward: self.append_gradients(result, [input]) class TFGather(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False, dtype=None): import tensorflow as tf self.name = "gather" self.allow_growth = True input = tf.placeholder(name='input', shape=config.input_shape, dtype=tf.float32) index = tf.placeholder(name='index', shape=config.index_shape, dtype=tf.int32) result = tf.gather(params=input, indices=index) self.feed_list = [input, index] self.fetch_list = [result] if backward: self.append_gradients(result, [input, index]) if __name__ == '__main__': test_main(PDGather(), TFGather(), feed_spec=config.feed_spec)
dtype='float32', lod_level=0) data.stop_gradient = False value, indices = fluid.layers.topk(input=data, k=5) self.feed_vars = [data] self.fetch_vars = [value, indices] if backward: self.append_gradients([value, indices], [data]) class TFTopK(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False, dtype=None): import tensorflow as tf self.name = "topk" self.allow_growth = True data = tf.placeholder(name='data', shape=[16, 1000], dtype=tf.float32) value, indices = tf.math.top_k(input=data, k=5) self.feed_list = [data] self.fetch_list = [value, indices] if backward: self.append_gradients([value, indices], [data]) if __name__ == '__main__': test_main(PDTopK(), TFTopK(), feed_spec=None)
seed=123, dropout_implementation="upscale_in_train") self.feed_vars = [data] self.fetch_vars = [result] if backward: self.append_gradients(result, [data]) class TFDropout(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False, dtype=None): import tensorflow as tf self.name = "dropout" self.allow_growth = True data = tf.placeholder(name='data', shape=[10, 10, 100, 100], dtype=tf.float32) result = tf.nn.dropout(x=data, rate=0.2, noise_shape=None, seed=123) self.feed_list = [data] self.fetch_list = [result] if backward: self.append_gradients(result, [data]) if __name__ == '__main__': # Not consitent!!! test_main(PDDropout(), TFDropout(), feed_spec=None)
self.feed_vars = [data1, data2] self.fetch_vars = [result] if backward: self.append_gradients(result, [data1, data2]) class TFConcat(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False): import tensorflow as tf self.name = "concat" self.allow_growth = True data1 = tf.placeholder(name='data1', shape=[100, 200], dtype=tf.float32) data2 = tf.placeholder(name='data2', shape=[100, 200], dtype=tf.float32) result = tf.concat([data1, data2], 0) self.feed_list = [data1, data2] self.fetch_list = [result] if backward: self.append_gradients(result, [data1, data2]) if __name__ == '__main__': test_main(PDConcat(), TFConcat(), feed_spec=None)
class TFSoftmaxWithCrossEntropy(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False, dtype=None): import tensorflow as tf self.name = "softmax_with_cross_entropy" self.allow_growth = True input = tf.placeholder(name='input', shape=config.input_shape, dtype=tf.float32) label = tf.placeholder(name='label', shape=config.label_shape(for_tensorflow=True), dtype=tf.int32) onehot_label = tf.one_hot(indices=label, depth=config.num_classes) result = tf.losses.softmax_cross_entropy(logits=input, onehot_labels=onehot_label) self.feed_list = [input, label] self.fetch_list = [result] if backward: self.append_gradients(result, [input]) if __name__ == '__main__': # Not consistent!!! test_main(PDSoftmaxWithCrossEntropy(), TFSoftmaxWithCrossEntropy(), feed_spec=config.feed_spec)
lod_level=0) input.stop_gradient = False result = fluid.layers.cast(input, dtype=config.dtype) self.feed_vars = [input] self.fetch_vars = [result] if backward: self.append_gradients(result, [input]) class TFCast(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False, dtype=None): import tensorflow as tf self.name = "cast" self.allow_growth = True input = tf.placeholder(name='input', shape=config.input_shape, dtype=tf.float32) result = tf.cast(input, dtype=config.dtype) self.feed_list = [input] self.fetch_list = [result] if backward: self.append_gradients(result, [input]) if __name__ == '__main__': test_main(PDCast(), TFCast(), feed_spec=config.feed_spec)
lod_level=0) data.stop_gradient = False result = fluid.layers.squeeze(data, axes=[]) self.feed_vars = [data] self.fetch_vars = [result] if backward: self.append_gradients(result, [data]) class TFSqueeze(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False, dtype=None): import tensorflow as tf self.name = "squeeze" self.allow_growth = True data = tf.placeholder(name='data', shape=[1, 10, 100, 1, 100], dtype=tf.float32) result = tf.squeeze(data) self.feed_list = [data] self.fetch_list = [result] if backward: self.append_gradients(result, [data]) if __name__ == '__main__': test_main(PDSqueeze(), TFSqueeze(), feed_spec=None)
model = enc_dec_model(args) test_model = enc_dec_model(args) elif args.model_name == 'DNN_naive': model = DNN_naive(args, args.dnn_hidden) test_model = DNN_naive(args, args.dnn_hidden) model.to(args.device) print("-----Setting the Optimizer-----") if args.opt == 'Adam': optimizer = optim.Adam(model.parameters(), lr=args.learning_rate) elif args.opt == 'RMSprop': optimizer = optim.RMSprop(model.parameters(), lr=args.learning_rate) elif args.opt == 'Adadelta': optimizer = optim.Adadelta(model.parameters(), lr=args.learning_rate) elif args.opt == 'SGD': optimizer = optim.SGD(model.parameters(), lr=args.learning_rate, momentum=0.9) train_log = train_main(args, train_loader, valid_loader, model, optimizer) print("Loading Best model for testing") best_model_path = args.save_model_path + '.best.pth' tmp_model = torch.load(best_model_path) state_dict = tmp_model.state_dict() test_model.load_state_dict(state_dict) test_model.to(args.device) use = 'test' test_main(args, test_model, test_loader, use, train_log)
class TFConv2d(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False, dtype=None): import tensorflow as tf self.name = "conv2d" self.allow_growth = True input = tf.placeholder(name='input', shape=config.input_shape, dtype=tf.float32) filter = tf.placeholder(name='filter', shape=config.filter_shape(for_tensorflow=True), dtype=tf.float32) result = tf.nn.conv2d(input=input, filter=filter, strides=config.stride, padding=config.padding(for_tensorflow=True), data_format=config.data_format, dilations=config.dilation, use_cudnn_on_gpu=config.use_cudnn) self.feed_list = [input, filter] self.fetch_list = [result] if backward: self.append_gradients(result, [input]) if __name__ == '__main__': test_main(PDConv2d(), TFConv2d(), feed_spec=config.feed_spec)
if backward: self.append_gradients(result, [x, y]) class TFMatmul(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False): import tensorflow as tf self.name = "matmul" self.allow_growth = True x = tf.placeholder(name='x', shape=config.x_shape, dtype=tf.float32) y = tf.placeholder(name='y', shape=config.y_shape, dtype=tf.float32) result = tf.matmul(a=x, b=y, transpose_a=config.transpose_x, transpose_b=config.transpose_y, adjoint_a=False, adjoint_b=False, a_is_sparse=False, b_is_sparse=False) self.feed_list = [x, y] self.fetch_list = [result] if backward: self.append_gradients(result, [x, y]) if __name__ == '__main__': test_main(PDMatmul(), TFMatmul(), feed_spec=None)
starts = [0, 1, 1, 0] ends = [3, 8, 50, 30] result = fluid.layers.slice(data, axes=axes, starts=starts, ends=ends) self.feed_vars = [data] self.fetch_vars = [result] if backward: self.append_gradients(result, [data]) class TFSlice(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False, dtype=None): import tensorflow as tf self.name = "slice" self.allow_growth = True data = tf.placeholder(name='data', shape=[10, 10, 100, 100], dtype=tf.float32) begin = [0, 1, 1, 0] size = [3, 7, 49, 30] result = tf.slice(data, begin, size) self.feed_list = [data] self.fetch_list = [result] if backward: self.append_gradients(result, [data]) if __name__ == '__main__': test_main(PDSlice(), TFSlice(), feed_spec=None)
with fluid.program_guard(self.main_program, self.startup_program): data = fluid.data( name='data', shape=[10, 10, 100, 100], dtype='float32', lod_level=0) data.stop_gradient = False result = fluid.layers.sigmoid(data) self.feed_vars = [data] self.fetch_vars = [result] if backward: self.append_gradients(result, [data]) class TFSigmoid(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False): import tensorflow as tf self.name = "sigmoid" self.allow_growth = True data = tf.placeholder(name='data', shape=[10, 10, 100, 100], dtype=tf.float32) result = tf.math.sigmoid(data) self.feed_list = [data] self.fetch_list = [result] if backward: self.append_gradients(result, [data]) if __name__ == '__main__': test_main(PDSigmoid(), TFSigmoid(), feed_spec=None)
lod_level=0) data.stop_gradient = False result = fluid.layers.abs(x=data) self.feed_vars = [data] self.fetch_vars = [result] if backward: self.append_gradients(result, [data]) class TFAbs(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False, dtype=None): import tensorflow as tf self.name = "abs" self.allow_growth = True data = tf.placeholder(name='data', shape=config.input_shape, dtype=tf.float32) result = tf.abs(x=data) self.feed_list = [data] self.fetch_list = [result] if backward: self.append_gradients(result, [data]) if __name__ == '__main__': test_main(PDAbs(), TFAbs(), feed_spec=config.feed_spec)
lod_level=0) x.stop_gradient = False result = fluid.layers.expand(x=x, expand_times=config.expand_times) self.feed_vars = [x] self.fetch_vars = [result] if backward: self.append_gradients(result, [x]) class TFExpand(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False, dtype=None): import tensorflow as tf self.name = "expand" self.allow_growth = True data = tf.placeholder(name='data', shape=config.x_shape, dtype=tf.float32) result = tf.tile(input=data, multiples=config.expand_times) self.feed_list = [data] self.fetch_list = [result] if backward: self.append_gradients(result, [data]) if __name__ == '__main__': test_main(PDExpand(), TFExpand(), feed_spec=None)
lod_level=0) data.stop_gradient = False result = fluid.layers.transpose(x=data, perm=[2, 3, 0, 1]) self.feed_vars = [data] self.fetch_vars = [result] if backward: self.append_gradients(result, [data]) class TFTranspose(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False, dtype=None): import tensorflow as tf self.name = "transpose" self.allow_growth = True data = tf.placeholder(name='data', shape=[10, 10, 100, 100], dtype=tf.float32) result = tf.transpose(a=data, perm=[2, 3, 0, 1], conjugate=False) self.feed_list = [data] self.fetch_list = [result] if backward: self.append_gradients(result, [data]) if __name__ == '__main__': test_main(PDTranspose(), TFTranspose(), feed_spec=None)
from common import paddle_api_benchmark as paddle_api class PDConv2dTranspose(paddle_api.PaddleAPIBenchmarkBase): def build_program(self, backward=False, dtype=None): import paddle.fluid as fluid self.name = "conv2d_transpose" with fluid.program_guard(self.main_program, self.startup_program): input = fluid.data(name='input', shape=[1, 1, 80, 63], dtype=dtype, lod_level=0) input.stop_gradient = False result = fluid.layers.conv2d_transpose(input=input, num_filters=1, filter_size=(3, 32), padding=(1, 8), stride=(1, 16), bias_attr=False, use_cudnn=True) self.feed_vars = [input] self.fetch_vars = [result] if backward: self.append_gradients(result, [input]) if __name__ == '__main__': test_main(PDConv2dTranspose(), feed_spec=None)
self.fetch_vars = [result] if backward: self.append_gradients(result, [input]) class TFFC(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False, dtype=None): import tensorflow as tf self.name = "fc" self.allow_growth = True input = tf.placeholder(name='input', shape=config.input_shape, dtype=tf.float32) result = tf.contrib.layers.fully_connected( inputs=input, num_outputs=config.size, weights_initializer=tf.constant_initializer(0.5), biases_initializer=tf.constant_initializer(0.1), activation_fn=None) self.feed_list = [input] self.fetch_list = [result] if backward: self.append_gradients(result, [input]) if __name__ == '__main__': test_main(PDFC(), TFFC(), feed_spec=None)
name='y', shape=[1, 128, 1000], dtype='float32', lod_level=0) x.stop_gradient = False y.stop_gradient = False result = fluid.layers.elementwise_mul(x=x, y=y, act=None) self.feed_vars = [x, y] self.fetch_vars = [result] if backward: self.append_gradients(result, [x, y]) class TFElementwiseMul(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False, dtype=None): import tensorflow as tf self.name = "elementwise_mul" self.allow_growth = True x = tf.placeholder(name='x', shape=[50, 128, 1000], dtype=tf.float32) y = tf.placeholder(name='y', shape=[1, 128, 1000], dtype=tf.float32) result = tf.multiply(x=x, y=y) self.feed_list = [x, y] self.fetch_list = [result] if backward: self.append_gradients(result, [x, y]) if __name__ == '__main__': test_main(PDElementwiseMul(), TFElementwiseMul(), feed_spec=None)
input.stop_gradient = False result = fluid.layers.assign(input) self.feed_vars = [input] self.fetch_vars = [result] if backward: self.append_gradients(result, [input]) class TFAssign(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False, dtype=None): import tensorflow as tf self.name = "assign" self.allow_growth = True input = tf.placeholder( name='input', shape=config.input_shape, dtype=tf.float32) ref = tf.Variable( tf.zeros(config.input_shape), name='target', dtype=tf.float32) assigns = tf.assign(ref=ref, value=input) self.feed_list = [input] self.fetch_list = [assigns] if backward: self.append_gradients(assigns, [input]) if __name__ == '__main__': test_main(PDAssign(), TFAssign(), feed_spec=None)
result = fluid.embedding( input=input, size=config.table_shape, param_attr='table') self.feed_vars = [input, table] self.fetch_vars = [result] if backward: self.append_gradients(result, [table]) class TFEmbedding(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False): import tensorflow as tf self.name = "embedding" self.allow_growth = True input = tf.placeholder( name='input', shape=config.input_shape, dtype=tf.int64) table = tf.placeholder( name='table', shape=config.table_shape, dtype=tf.float32) result = tf.nn.embedding_lookup(ids=input, params=table, max_norm=None) self.feed_list = [input, table] self.fetch_list = [result] if backward: self.append_gradients(result, [table]) if __name__ == '__main__': test_main(PDEmbedding(), TFEmbedding(), feed_spec=config.feed_spec)
lod_level=0) data.stop_gradient = False result = fluid.layers.softmax(input=data, use_cudnn=False, axis=-1) self.feed_vars = [data] self.fetch_vars = [result] if backward: self.append_gradients(result, [data]) class TFSoftmax(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False, dtype=None): import tensorflow as tf self.name = "softmax" self.allow_growth = True data = tf.placeholder(name='data', shape=[16, 10, 100], dtype=tf.float32) result = tf.nn.softmax(logits=data, axis=-1) self.feed_list = [data] self.fetch_list = [result] if backward: self.append_gradients(result, [data]) if __name__ == '__main__': test_main(PDSoftmax(), TFSoftmax(), feed_spec=None)
self.allow_growth = True input = tf.placeholder(name='input', shape=config.input_shape, dtype=tf.float32) scale = tf.placeholder(name='scale', shape=[config.num_channels], dtype=tf.float32) bias = tf.placeholder(name='bias', shape=[config.num_channels], dtype=tf.float32) mean, var = tf.nn.moments(x=input, axes=config.axes, shift=None, keepdims=False) result = tf.nn.batch_normalization(x=input, mean=mean, variance=var, offset=bias, scale=scale, variance_epsilon=config.epsilon) self.feed_list = [input, scale, bias] self.fetch_list = [result] if backward: self.append_gradients(result, [input, scale, bias]) if __name__ == '__main__': test_main(PDBatchNorm(), TFBatchNorm(), feed_spec=None)
self.feed_vars = [data1, data2] self.fetch_vars = [result] if backward: self.append_gradients(result, [data1, data2]) class TFStack(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False, dtype=None): import tensorflow as tf self.name = "stack" self.allow_growth = True data1 = tf.placeholder(name='data1', shape=[10, 10, 100, 100], dtype=tf.float32) data2 = tf.placeholder(name='data2', shape=[10, 10, 100, 100], dtype=tf.float32) result = tf.stack([data1, data2], axis=1) self.feed_list = [data1, data2] self.fetch_list = [result] if backward: self.append_gradients(result, [data1, data2]) if __name__ == '__main__': test_main(PDStack(), TFStack(), feed_spec=None)
lod_level=0) data.stop_gradient = False result = fluid.layers.reduce_sum(input=data, dim=-1, keep_dim=False) self.feed_vars = [data] self.fetch_vars = [result] if backward: self.append_gradients(result, [data]) class TFReduceSum(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False, dtype=None): import tensorflow as tf self.name = "reduce_sum" self.allow_growth = True data = tf.placeholder(name='data', shape=[32, 768], dtype=tf.float32) result = tf.reduce_sum(input_tensor=data, axis=-1, keepdims=False) self.feed_list = [data] self.fetch_list = [result] if backward: self.append_gradients(result, [data]) if __name__ == '__main__': test_main(PDReduceSum(), TFReduceSum(), feed_spec=None)
data, num_or_sections=[1, 2, 7], dim=1) self.feed_vars = [data] self.fetch_vars = [result1, result2, result3] if backward: self.append_gradients([result1, result2, result3], [data]) class TFSplit(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False, dtype=None): import tensorflow as tf self.name = "split" self.allow_growth = True data = tf.placeholder(name='data', shape=[10, 10, 100, 100], dtype=tf.float32) result1, result2, result3 = tf.split(value=data, num_or_size_splits=[1, 2, 7], axis=1) self.feed_list = [data] self.fetch_list = [result1, result2, result3] if backward: self.append_gradients([result1, result2, result3], [data]) if __name__ == '__main__': test_main(PDSplit(), TFSplit(), feed_spec=None)
self.fetch_vars = [result] if backward: self.append_gradients(result, [input]) class TFPool2d(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False, dtype=None): import tensorflow as tf self.name = "pool2d" self.allow_growth = True input = tf.placeholder(name='input', shape=config.input_shape, dtype=tf.float32) result = tf.nn.pool(input, window_shape=config.pool_size, pooling_type=config.pool_type(), strides=config.pool_stride, padding=config.pool_padding(for_tensorflow=True), data_format=config.data_format) self.feed_list = [input] self.fetch_list = [result] if backward: self.append_gradients(result, [input]) if __name__ == '__main__': test_main(PDPool2d(), TFPool2d(), feed_spec=None)
parser.add_argument("--model_path", type=str, default='') parser.add_argument("--save_dir", type=str, default='./result/') parser.add_argument("--dataset_path", type=str, default='') parser.add_argument("--save_log_path", type=str, default='') parser.add_argument("--n_valid_print", type=int, default=3) parser.add_argument("--rank_method", type=str, default=['sfcid', 'src_max', 'dst_max']) parser.add_argument("--use", type=str, default='test') args = parser.parse_args() args.cuda = torch.cuda.is_available() args.device = torch.device("cuda" if args.cuda else "cpu") print("-----Loading Training Dataset-----") placement = load_placement(args.raw_placement_dataset_path) dataset_path = args.dataset_path dataset = pd.read_csv(dataset_path, index_col=0) dataset = np.array(dataset) data_loader = sfc_dataset(args, dataset, placement) print("# of dataset : {}".format(data_loader.len())) print("-----Building the Model-----") test_model = torch.load(args.model_path) test_model.to(args.device) test_main(args, test_model, data_loader, use=args.use)
input.stop_gradient = False result = fluid.one_hot(input=input, depth=config.depth) self.feed_vars = [input] self.fetch_vars = [result] class TFOneHot(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False, dtype=None): import tensorflow as tf self.name = "one_hot" self.allow_growth = True input = tf.placeholder( name='input', shape=config.input_shape, dtype=tf.int32) result = tf.one_hot( indices=input, depth=config.depth, on_value=None, off_value=None, axis=None, dtype=None) self.feed_list = [input] self.fetch_list = [result] if __name__ == '__main__': test_main(PDOneHot(), TFOneHot(), feed_spec=config.feed_spec)
lod_level=0) data.stop_gradient = False result = fluid.layers.reshape(x=data, shape=config.shape) self.feed_vars = [data] self.fetch_vars = [result] if backward: self.append_gradients(result, [data]) class TFReshape(tensorflow_api.TensorflowAPIBenchmarkBase): def build_graph(self, backward=False, dtype=None): import tensorflow as tf self.name = "reshape" self.allow_growth = True data = tf.placeholder(name='data', shape=config.x_shape, dtype=tf.float32) result = tf.reshape(tensor=data, shape=config.shape) self.feed_list = [data] self.fetch_list = [result] if backward: self.append_gradients(result, [data]) if __name__ == '__main__': test_main(PDReshape(), TFReshape(), feed_spec=None)