FM / operator

/usr/local/lib64/python3.6/site-packages/caffe2/python/operator_test/

/usr/local/lib64/python3.6/site-packages/caffe2/python/operator_test

Name	Size	Mode	Actions
__pycache__/	-	0755	rm
activation_ops_test.py	9691	0644	edit dl rm
adadelta_test.py	7932	0644	edit dl rm
adagrad_test.py	7586	0644	edit dl rm
adagrad_test_helper.py	5181	0644	edit dl rm
adam_test.py	21559	0644	edit dl rm
affine_channel_op_test.py	3784	0644	edit dl rm
alias_with_name_test.py	938	0644	edit dl rm
apmeter_test.py	2738	0644	edit dl rm
arg_ops_test.py	1917	0644	edit dl rm
assert_test.py	797	0644	edit dl rm
async_net_barrier_test.py	946	0644	edit dl rm
atomic_ops_test.py	4104	0644	edit dl rm
basic_rnn_test.py	4720	0644	edit dl rm
batch_box_cox_test.py	5080	0644	edit dl rm
batch_bucketize_op_test.py	3730	0644	edit dl rm
batch_moments_op_test.py	2795	0644	edit dl rm
batch_sparse_to_dense_op_test.py	4199	0644	edit dl rm
bbox_transform_test.py	12258	0644	edit dl rm
bisect_percentile_op_test.py	6227	0644	edit dl rm
blobs_queue_db_test.py	3240	0644	edit dl rm
boolean_mask_test.py	16389	0644	edit dl rm
boolean_unmask_test.py	1711	0644	edit dl rm
box_with_nms_limit_op_test.py	8750	0644	edit dl rm
bucketize_op_test.py	930	0644	edit dl rm
cast_op_test.py	1600	0644	edit dl rm
ceil_op_test.py	888	0644	edit dl rm
channel_backprop_stats_op_test.py	2131	0644	edit dl rm
channel_shuffle_test.py	1794	0644	edit dl rm
channel_stats_op_test.py	2639	0644	edit dl rm
checkpoint_test.py	1500	0644	edit dl rm
clip_op_test.py	1984	0644	edit dl rm
clip_tensor_op_test.py	2076	0644	edit dl rm
collect_and_distribute_fpn_rpn_proposals_op_test.py	11269	0644	edit dl rm
concat_op_cost_test.py	2858	0644	edit dl rm
concat_split_op_test.py	7266	0644	edit dl rm
conditional_test.py	995	0644	edit dl rm
conftest.py	1446	0644	edit dl rm
conv_test.py	32473	0644	edit dl rm
conv_transpose_test.py	15945	0644	edit dl rm
copy_ops_test.py	7374	0644	edit dl rm
copy_rows_to_tensor_op_test.py	2526	0644	edit dl rm
cosine_embedding_criterion_op_test.py	1953	0644	edit dl rm
counter_ops_test.py	3348	0644	edit dl rm
crf_test.py	5315	0644	edit dl rm
cross_entropy_ops_test.py	10085	0644	edit dl rm
ctc_beam_search_decoder_op_test.py	5197	0644	edit dl rm
ctc_greedy_decoder_op_test.py	4743	0644	edit dl rm
cudnn_recurrent_test.py	5817	0644	edit dl rm
dataset_ops_test.py	23847	0644	edit dl rm
data_couple_op_test.py	858	0644	edit dl rm
decay_adagrad_test.py	2694	0644	edit dl rm
deform_conv_test.py	19276	0644	edit dl rm
dense_vector_to_id_list_op_test.py	2044	0644	edit dl rm
depthwise_3x3_conv_test.py	1863	0644	edit dl rm
detectron_keypoints.py	7973	0644	edit dl rm
distance_op_test.py	4351	0644	edit dl rm
dropout_op_test.py	2971	0644	edit dl rm
duplicate_operands_test.py	734	0644	edit dl rm
elementwise_linear_op_test.py	1382	0644	edit dl rm
elementwise_logical_ops_test.py	4617	0644	edit dl rm
elementwise_ops_test.py	33354	0644	edit dl rm
elementwise_op_broadcast_test.py	17466	0644	edit dl rm
emptysample_ops_test.py	1977	0644	edit dl rm
enforce_finite_op_test.py	1286	0644	edit dl rm
ensure_clipped_test.py	1505	0644	edit dl rm
ensure_cpu_output_op_test.py	1244	0644	edit dl rm
erf_op_test.py	749	0644	edit dl rm
expand_op_test.py	2109	0644	edit dl rm
fc_operator_test.py	3720	0644	edit dl rm
feature_maps_ops_test.py	21492	0644	edit dl rm
filler_ops_test.py	8476	0644	edit dl rm
find_op_test.py	1316	0644	edit dl rm
flatten_op_test.py	922	0644	edit dl rm
flexible_top_k_test.py	2609	0644	edit dl rm
floor_op_test.py	894	0644	edit dl rm
fused_nbit_rowwise_conversion_ops_test.py	14077	0644	edit dl rm
fused_nbit_rowwise_test_helper.py	2693	0644	edit dl rm
gather_ops_test.py	9216	0644	edit dl rm
gather_ranges_op_test.py	9125	0644	edit dl rm
given_tensor_byte_string_to_uint8_fill_op_test.py	1392	0644	edit dl rm
given_tensor_fill_op_test.py	1503	0644	edit dl rm
glu_op_test.py	1212	0644	edit dl rm
group_conv_test.py	2870	0644	edit dl rm
group_norm_op_test.py	5252	0644	edit dl rm
gru_test.py	12932	0644	edit dl rm
heatmap_max_keypoint_op_test.py	4770	0644	edit dl rm
histogram_test.py	3097	0644	edit dl rm
hsm_test.py	9456	0644	edit dl rm
hyperbolic_ops_test.py	1472	0644	edit dl rm
im2col_col2im_test.py	4311	0644	edit dl rm
image_input_op_test.py	17345	0644	edit dl rm
index_hash_ops_test.py	2885	0644	edit dl rm
index_ops_test.py	4597	0644	edit dl rm
instance_norm_test.py	9917	0644	edit dl rm
integral_image_ops_test.py	3419	0644	edit dl rm
jsd_ops_test.py	1044	0644	edit dl rm
key_split_ops_test.py	1289	0644	edit dl rm
lars_test.py	1354	0644	edit dl rm
layer_norm_op_test.py	14983	0644	edit dl rm
leaky_relu_test.py	5639	0644	edit dl rm
learning_rate_adaption_op_test.py	2837	0644	edit dl rm
learning_rate_op_test.py	8652	0644	edit dl rm
lengths_pad_op_test.py	1625	0644	edit dl rm
lengths_reducer_fused_nbit_rowwise_ops_test.py	15495	0644	edit dl rm
lengths_tile_op_test.py	1332	0644	edit dl rm
lengths_top_k_ops_test.py	2371	0644	edit dl rm
length_split_op_test.py	4868	0644	edit dl rm
listwise_l2r_operator_test.py	8740	0644	edit dl rm
load_save_test.py	33241	0644	edit dl rm
locally_connected_op_test.py	7761	0644	edit dl rm
loss_ops_test.py	902	0644	edit dl rm
lpnorm_op_test.py	2725	0644	edit dl rm
map_ops_test.py	2249	0644	edit dl rm
margin_ranking_criterion_op_test.py	1816	0644	edit dl rm
math_ops_test.py	1603	0644	edit dl rm
matmul_op_test.py	10096	0644	edit dl rm
mean_op_test.py	1469	0644	edit dl rm
merge_id_lists_op_test.py	2989	0644	edit dl rm
mkl_conv_op_test.py	1547	0644	edit dl rm
mkl_packed_fc_op_test.py	2647	0644	edit dl rm
mod_op_test.py	1459	0644	edit dl rm
moments_op_test.py	1722	0644	edit dl rm
momentum_sgd_test.py	6480	0644	edit dl rm
mpi_test.py	8154	0644	edit dl rm
mul_gradient_benchmark.py	1509	0644	edit dl rm
negate_gradient_op_test.py	1518	0644	edit dl rm
ngram_ops_test.py	2327	0644	edit dl rm
normalize_op_test.py	1679	0644	edit dl rm
numpy_tile_op_test.py	1924	0644	edit dl rm
one_hot_ops_test.py	7478	0644	edit dl rm
onnx_while_test.py	3070	0644	edit dl rm
order_switch_test.py	1306	0644	edit dl rm
pack_ops_test.py	12634	0644	edit dl rm
pack_rnn_sequence_op_test.py	2891	0644	edit dl rm
pad_test.py	1377	0644	edit dl rm
partition_ops_test.py	6838	0644	edit dl rm
percentile_op_test.py	4427	0644	edit dl rm
piecewise_linear_transform_test.py	6187	0644	edit dl rm
pooling_test.py	16508	0644	edit dl rm
prepend_dim_test.py	1505	0644	edit dl rm
python_op_test.py	1312	0644	edit dl rm
quantile_test.py	3276	0644	edit dl rm
rand_quantization_op_speed_test.py	3128	0644	edit dl rm
rank_loss_operator_test.py	5752	0644	edit dl rm
rebatching_queue_test.py	9047	0644	edit dl rm
record_queue_test.py	3125	0644	edit dl rm
recurrent_network_test.py	14048	0644	edit dl rm
recurrent_net_executor_test.py	10922	0644	edit dl rm
reduce_ops_test.py	17341	0644	edit dl rm
reduction_ops_test.py	4664	0644	edit dl rm
reshape_ops_test.py	8211	0644	edit dl rm
resize_op_test.py	9417	0644	edit dl rm
rmac_regions_op_test.py	3178	0644	edit dl rm
rms_norm_op_test.py	1325	0644	edit dl rm
rnn_cell_test.py	59707	0644	edit dl rm
roi_align_rotated_op_test.py	7567	0644	edit dl rm
rowwise_counter_test.py	2205	0644	edit dl rm
scale_op_test.py	2177	0644	edit dl rm
segment_ops_test.py	25745	0644	edit dl rm
self_binning_histogram_test.py	12915	0644	edit dl rm
selu_op_test.py	3232	0644	edit dl rm
sequence_ops_test.py	16000	0644	edit dl rm
shape_inference_test.py	25708	0644	edit dl rm
sinusoid_position_encoding_op_test.py	2308	0644	edit dl rm
softmax_ops_test.py	23685	0644	edit dl rm
softplus_op_test.py	516	0644	edit dl rm
sparse_dropout_with_replacement_op_test.py	2885	0644	edit dl rm
sparse_gradient_checker_test.py	1294	0644	edit dl rm
sparse_itemwise_dropout_with_replacement_op_test.py	2913	0644	edit dl rm
sparse_lengths_sum_benchmark.py	4159	0644	edit dl rm
sparse_lp_regularizer_test.py	2553	0644	edit dl rm
sparse_normalize_test.py	3136	0644	edit dl rm
sparse_ops_test.py	3469	0644	edit dl rm
sparse_to_dense_mask_op_test.py	3693	0644	edit dl rm
spatial_bn_op_test.py	20182	0644	edit dl rm
specialized_segment_ops_test.py	11775	0644	edit dl rm
split_op_cost_test.py	8645	0644	edit dl rm
square_root_divide_op_test.py	2179	0644	edit dl rm
stats_ops_test.py	1789	0644	edit dl rm
stats_put_ops_test.py	6596	0644	edit dl rm
storm_test.py	6507	0644	edit dl rm
string_ops_test.py	4154	0644	edit dl rm
text_file_reader_test.py	2517	0644	edit dl rm
thresholded_relu_op_test.py	2323	0644	edit dl rm
tile_op_test.py	3887	0644	edit dl rm
top_k_test.py	9113	0644	edit dl rm
torch_integration_test.py	39941	0644	edit dl rm
transpose_op_test.py	2722	0644	edit dl rm
trigonometric_op_test.py	1715	0644	edit dl rm
unique_ops_test.py	2255	0644	edit dl rm
unique_uniform_fill_op_test.py	1335	0644	edit dl rm
unsafe_coalesce_test.py	2940	0644	edit dl rm
upsample_op_test.py	7308	0644	edit dl rm
utility_ops_test.py	15054	0644	edit dl rm
video_input_op_test.py	10503	0644	edit dl rm
weighted_multi_sample_test.py	1997	0644	edit dl rm
weighted_sample_test.py	2739	0644	edit dl rm
weighted_sum_test.py	3052	0644	edit dl rm
weight_scale_test.py	2057	0644	edit dl rm
wngrad_test.py	8279	0644	edit dl rm
__init__.py	0	0644	edit dl rm

Edit: /usr/local/lib64/python3.6/site-packages/caffe2/python/operator_test/recurrent_net_executor_test.py (10922B)

from caffe2.proto import caffe2_pb2
from caffe2.python import model_helper, workspace, core, rnn_cell, test_util
from caffe2.python.attention import AttentionType

import numpy as np

import unittest
import caffe2.python.hypothesis_test_util as hu
import hypothesis.strategies as st
from hypothesis import given, settings

class TestRNNExecutor(test_util.TestCase):

def setUp(self):
        super(TestRNNExecutor, self).setUp()
        self.batch_size = 8
        self.input_dim = 20
        self.hidden_dim = 30
        self.encoder_dim = 40

@given(
        T=st.integers(10, 100),
        forward_only=st.booleans(),
        **hu.gcs)
    @settings(deadline=10000)
    def test_lstm_with_attention_equal_simplenet(self, T, forward_only, gc, dc):
        self.Tseq = [T, T // 2, T // 2 + T // 4, T, T // 2 + 1]
        workspace.ResetWorkspace()
        with core.DeviceScope(gc):
            print("Run with device: {}, forward only: {}".format(
                gc, forward_only))

workspace.FeedBlob(
                "seq_lengths",
                np.array([T] * self.batch_size, dtype=np.int32)
            )
            workspace.FeedBlob("target", np.random.rand(
                T, self.batch_size, self.hidden_dim).astype(np.float32))
            workspace.FeedBlob("hidden_init", np.zeros(
                [1, self.batch_size, self.hidden_dim], dtype=np.float32
            ))
            workspace.FeedBlob("cell_init", np.zeros(
                [1, self.batch_size, self.hidden_dim], dtype=np.float32
            ))

model = model_helper.ModelHelper(name="lstm")
            model.net.AddExternalInputs(["input"])

init_blobs = []
            hidden_init, cell_init, encoder_outputs = model.net.AddExternalInputs(
                "hidden_init",
                "cell_init",
                "encoder_outputs"
            )

awec_init = model.net.AddExternalInputs([
                'initial_attention_weighted_encoder_context',
            ])
            init_blobs.extend([hidden_init, cell_init])

workspace.FeedBlob(
                awec_init,
                np.random.rand(1, self.batch_size, self.encoder_dim).astype(
                    np.float32),
            )
            workspace.FeedBlob(
                encoder_outputs,
                np.random.rand(1, self.batch_size, self.encoder_dim).astype(
                    np.float32),
            )

outputs = rnn_cell.LSTMWithAttention(
                model=model,
                decoder_inputs="input",
                decoder_input_lengths="seq_lengths",
                initial_decoder_hidden_state=hidden_init,
                initial_decoder_cell_state=cell_init,
                initial_attention_weighted_encoder_context=awec_init,
                encoder_output_dim=self.encoder_dim,
                encoder_outputs=encoder_outputs,
                encoder_lengths=None,
                decoder_input_dim=self.input_dim,
                decoder_state_dim=self.hidden_dim,
                scope="",
                attention_type=AttentionType.Recurrent,
                forward_only=forward_only,
                outputs_with_grads=[0],
            )
            output = outputs[0]

print(outputs)
            loss = model.AveragedLoss(
                model.SquaredL2Distance([output, "target"], "dist"),
                "loss"
            )
            # Add gradient ops
            if not forward_only:
                model.AddGradientOperators([loss])

# init
            for init_blob in init_blobs:
                workspace.FeedBlob(init_blob, np.zeros(
                    [1, self.batch_size, self.hidden_dim], dtype=np.float32
                ))

self._compare(model, forward_only)

def init_lstm_model(self, T, num_layers, forward_only, use_loss=True):
        workspace.FeedBlob(
            "seq_lengths",
            np.array([T] * self.batch_size, dtype=np.int32)
        )
        workspace.FeedBlob("target", np.random.rand(
            T, self.batch_size, self.hidden_dim).astype(np.float32))
        workspace.FeedBlob("hidden_init", np.zeros(
            [1, self.batch_size, self.hidden_dim], dtype=np.float32
        ))
        workspace.FeedBlob("cell_init", np.zeros(
            [1, self.batch_size, self.hidden_dim], dtype=np.float32
        ))

model = model_helper.ModelHelper(name="lstm")
        model.net.AddExternalInputs(["input"])

init_blobs = []
        for i in range(num_layers):
            hidden_init, cell_init = model.net.AddExternalInputs(
                "hidden_init_{}".format(i),
                "cell_init_{}".format(i)
            )
            init_blobs.extend([hidden_init, cell_init])

output, last_hidden, _, last_state = rnn_cell.LSTM(
            model=model,
            input_blob="input",
            seq_lengths="seq_lengths",
            initial_states=init_blobs,
            dim_in=self.input_dim,
            dim_out=[self.hidden_dim] * num_layers,
            scope="",
            drop_states=True,
            forward_only=forward_only,
            return_last_layer_only=True,
        )

if use_loss:
            loss = model.AveragedLoss(
                model.SquaredL2Distance([output, "target"], "dist"),
                "loss"
            )
            # Add gradient ops
            if not forward_only:
                model.AddGradientOperators([loss])

# init
        for init_blob in init_blobs:
            workspace.FeedBlob(init_blob, np.zeros(
                [1, self.batch_size, self.hidden_dim], dtype=np.float32
            ))

return model, output

def test_empty_sequence(self):
        '''
        Test the RNN executor's handling of empty input sequences
        '''
        Tseq = [0, 1, 2, 3, 0, 1]
        workspace.ResetWorkspace()
        with core.DeviceScope(caffe2_pb2.DeviceOption()):
            model, output = self.init_lstm_model(
                T=4, num_layers=1, forward_only=True, use_loss=False)

workspace.RunNetOnce(model.param_init_net)

self.enable_rnn_executor(model.net, 1, True)

np.random.seed(10022015)
            first_call = True
            for seq_len in Tseq:
                input_shape = [seq_len, self.batch_size, self.input_dim]
                workspace.FeedBlob(
                    "input", np.random.rand(*input_shape).astype(np.float32))
                workspace.FeedBlob(
                    "target",
                    np.random.rand(
                        seq_len, self.batch_size, self.hidden_dim
                    ).astype(np.float32))
                if first_call:
                    workspace.CreateNet(model.net, overwrite=True)
                    first_call = False

workspace.RunNet(model.net.Proto().name)
                val = workspace.FetchBlob(output)
                self.assertEqual(val.shape[0], seq_len)

@given(
        num_layers=st.integers(1, 8),
        T=st.integers(4, 100),
        forward_only=st.booleans(),
        **hu.gcs)
    @settings(deadline=10000)
    def test_lstm_equal_simplenet(self, num_layers, T, forward_only, gc, dc):
        '''
        Test that the RNN executor produces same results as
        the non-executor (i.e running step nets as sequence of simple nets).
        '''
        self.Tseq = [T, T // 2, T // 2 + T // 4, T, T // 2 + 1]

workspace.ResetWorkspace()
        with core.DeviceScope(gc):
            print("Run with device: {}, forward only: {}".format(
                gc, forward_only))

model, _ = self.init_lstm_model(T, num_layers, forward_only)
            self._compare(model, forward_only)

def _compare(self, model, forward_only):
        # Store list of blobs that exist in the beginning
        workspace.RunNetOnce(model.param_init_net)
        init_ws = {k: workspace.FetchBlob(k) for k in workspace.Blobs()}

# Run with executor
        for enable_executor in [0, 1]:
            self.enable_rnn_executor(model.net, enable_executor, forward_only)
            workspace.ResetWorkspace()

# Reset original state
            for k, v in init_ws.items():
                workspace.FeedBlob(k, v)

np.random.seed(10022015)
            ws = {}
            for j in range(len(self.Tseq)):
                input_shape = [self.Tseq[j], self.batch_size, self.input_dim]
                workspace.FeedBlob(
                    "input", np.random.rand(*input_shape).astype(np.float32))
                workspace.FeedBlob(
                    "target",
                    np.random.rand(
                        self.Tseq[j], self.batch_size, self.hidden_dim
                    ).astype(np.float32))
                if j == 0:
                    workspace.CreateNet(model.net, overwrite=True)

workspace.RunNet(model.net.Proto().name)

# Store results for each iteration
                for k in workspace.Blobs():
                    ws[k + "." + str(j)] = workspace.FetchBlob(k)

if enable_executor:
                rnn_exec_ws = ws
            else:
                non_exec_ws = ws

# Test that all blobs are equal after running with executor
        # or without.
        self.assertEqual(list(non_exec_ws.keys()), list(rnn_exec_ws.keys()))

mismatch = False
        for k in rnn_exec_ws.keys():
            non_exec_v = non_exec_ws[k]
            rnn_exec_v = rnn_exec_ws[k]
            if type(non_exec_v) is np.ndarray:
                if not np.allclose(non_exec_v, rnn_exec_v):
                    print("Mismatch: {}".format(k))
                    nv = non_exec_v.flatten()
                    rv = rnn_exec_v.flatten()
                    c = 0
                    for j in range(len(nv)):
                        if rv[j] != nv[j]:
                            print(j, rv[j], nv[j])
                            c += 1
                            if c == 10:
                                break

mismatch = True

self.assertFalse(mismatch)

def enable_rnn_executor(self, net, value, forward_only):
        num_found = 0
        for op in net.Proto().op:
            if op.type.startswith("RecurrentNetwork"):
                for arg in op.arg:
                    if arg.name == 'enable_rnn_executor':
                        arg.i = value
                        num_found += 1
        # This sanity check is so that if someone changes the
        # enable_rnn_executor parameter name, the test will
        # start failing as this function will become defective.
        self.assertEqual(1 if forward_only else 2, num_found)

if __name__ == "__main__":
    import random
    random.seed(2603)
    workspace.GlobalInit([
        'caffe2',
        '--caffe2_log_level=0',
        '--caffe2_rnn_executor=1'])
    unittest.main()

cmd: