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_network_test.py (14048B)

from caffe2.python import recurrent, workspace
from caffe2.python.model_helper import ModelHelper
from hypothesis import given, settings
import caffe2.python.hypothesis_test_util as hu
import caffe2.python.serialized_test.serialized_test_util as serial
import hypothesis.strategies as st
import numpy as np

class RecurrentNetworkTest(serial.SerializedTestCase):
    @given(T=st.integers(1, 4),
           n=st.integers(1, 5),
           d=st.integers(1, 5))
    @settings(deadline=10000)
    def test_sum_mul(self, T, n, d):
        model = ModelHelper(name='external')

input_blob, initial_input_blob = model.net.AddExternalInputs(
            'input', 'initial_input')

step = ModelHelper(name='step', param_model=model)
        input_t, output_t_prev = step.net.AddExternalInput(
            'input_t', 'output_t_prev')
        output_t_internal = step.net.Sum([input_t, output_t_prev])
        output_t = step.net.Mul([input_t, output_t_internal])
        step.net.AddExternalOutput(output_t)

self.simple_rnn(T, n, d, model, step, input_t, output_t, output_t_prev,
                        input_blob, initial_input_blob)

@given(T=st.integers(1, 4),
           n=st.integers(1, 5),
           d=st.integers(1, 5))
    @settings(deadline=10000)
    def test_mul(self, T, n, d):
        model = ModelHelper(name='external')

input_blob, initial_input_blob = model.net.AddExternalInputs(
            'input', 'initial_input')

step = ModelHelper(name='step', param_model=model)
        input_t, output_t_prev = step.net.AddExternalInput(
            'input_t', 'output_t_prev')
        output_t = step.net.Mul([input_t, output_t_prev])
        step.net.AddExternalOutput(output_t)

self.simple_rnn(T, n, d, model, step, input_t, output_t, output_t_prev,
                        input_blob, initial_input_blob)

@given(T=st.integers(1, 4),
           n=st.integers(1, 5),
           d=st.integers(1, 5))
    def test_extract(self, T, n, d):
        model = ModelHelper(name='external')
        workspace.ResetWorkspace()

input_blob, initial_input_blob = model.net.AddExternalInputs(
            'input', 'initial_input')

inputs = np.random.randn(T, n, d).astype(np.float32)
        initial_input = np.random.randn(1, n, d).astype(np.float32)
        recurrent.recurrent_net(
            net=model.net,
            cell_net=step.net,
            inputs=[(input_t, input_blob)],
            initial_cell_inputs=[(output_t_prev, initial_input_blob)],
            links={output_t_prev: output_t},
            scope="test_rnn_sum_mull",
        )

workspace.blobs[input_blob] = inputs
        workspace.blobs[initial_input_blob] = initial_input

workspace.RunNetOnce(model.param_init_net)
        workspace.CreateNet(model.net)

prefix = "extractTest"

workspace.RunNet(model.net.Proto().name, T)
        retrieved_blobs = recurrent.retrieve_step_blobs(
            model.net, prefix
        )

# needed for python3.6, which returns bytearrays instead of str
        retrieved_blobs = [x.decode() for x in retrieved_blobs]

for i in range(T):
            blob_name = prefix + "_" + "input_t" + str(i)
            self.assertTrue(
                blob_name in retrieved_blobs,
                "blob extraction failed on timestep {}\
                    . \n\n Extracted Blobs: {} \n\n Looking for {}\
                    .".format(i, retrieved_blobs, blob_name)
            )

def simple_rnn(self, T, n, d, model, step, input_t, output_t, output_t_prev,
                   input_blob, initial_input_blob):

input = np.random.randn(T, n, d).astype(np.float32)
        initial_input = np.random.randn(1, n, d).astype(np.float32)
        print(locals())
        recurrent.recurrent_net(
            net=model.net,
            cell_net=step.net,
            inputs=[(input_t, input_blob)],
            initial_cell_inputs=[(output_t_prev, initial_input_blob)],
            links={output_t_prev: output_t},
            scope="test_rnn_sum_mull",
        )
        workspace.blobs[input_blob] = input
        workspace.blobs[initial_input_blob] = initial_input

op = model.net._net.op[-1]
        # Just conviniently store all inputs in an array in the same
        # order as op.input
        inputs = [workspace.blobs[name] for name in op.input]

def reference(input, initial_input):
            global_ws_name = workspace.CurrentWorkspace()
            input_all = workspace.blobs[input_blob]

workspace.SwitchWorkspace("ref", create_if_missing=True)
            workspace.blobs[input_blob] = input
            workspace.blobs[output_t_prev] = initial_input.reshape(n, d)
            res_all = np.zeros(shape=input.shape, dtype=np.float32)

for t_cur in range(T):
                workspace.blobs[input_t] = input_all[t_cur]
                workspace.RunNetOnce(step.net)
                result_t = workspace.blobs[output_t]
                workspace.blobs[output_t_prev] = result_t
                res_all[t_cur] = result_t

workspace.SwitchWorkspace(global_ws_name)

shape = list(input.shape)
            shape[0] = 1
            return (res_all, res_all[-1].reshape(shape))

self.assertReferenceChecks(
            device_option=hu.cpu_do,
            op=op,
            inputs=inputs,
            reference=reference,
            output_to_grad=op.output[0],
            outputs_to_check=[0, 1],
        )

self.assertGradientChecks(
            device_option=hu.cpu_do,
            op=op,
            inputs=inputs,
            outputs_to_check=0,
            outputs_with_grads=[0],
            threshold=0.01,
            stepsize=0.005,
        )

# Hacky version of 1-D convolution
    def _convolution_1d(
        self,
        model,
        inputs,
        conv_window,
        conv_filter,
        conv_bias,
        output_name,
        left_pad,
    ):
        if left_pad:
            padding_width = conv_window - 1
        else:
            padding_width = 0

# [batch_size, inputs_length, state_size]
        inputs_transposed = model.net.Transpose(
            inputs,
            'inputs_transposed',
            axes=[1, 0, 2],
        )
        # [batch_size, 1, inputs_length, state_size]
        inputs_transposed_4d = model.net.ExpandDims(
            inputs_transposed,
            'inputs_transposed_4d',
            dims=[1],
        )
        # [batch_size, 1, inputs_length - conv_window + 1, state_size]
        output_transposed_4d = model.net.Conv(
            [inputs_transposed_4d, conv_filter, conv_bias],
            output_name + '_transposed_4d',
            kernel_h=1,
            kernel_w=conv_window,
            order='NHWC',
            pad_t=0,
            pad_l=padding_width,
            pad_b=0,
            pad_r=0,
        )
        # [batch_size, inputs_length - conv_window + 1, state_size]
        output_transposed = model.net.Squeeze(
            output_transposed_4d,
            output_name + '_transposed',
            dims=[1],
        )
        # [inputs_length - conv_window + 1, batch_size, state_size]
        output = model.net.Transpose(
            output_transposed,
            output_name,
            axes=[1, 0, 2],
        )
        return output

@given(sequence_length=st.integers(3, 7),
           conv_window=st.integers(1, 3),
           batch_size=st.integers(1, 5),
           state_size=st.integers(1, 5))
    def test_stateful_convolution_forward_only(
        self,
        sequence_length,
        conv_window,
        batch_size,
        state_size,
    ):
        '''
        This unit test demonstrates another ways of using RecurrentNetwork.

Imagine, that you want to compute convolution over a sequence,
        but sequence elements are not given to you from the beginning,
        so you have to loop over the sequence and compute convolution
        for each element separately. This situation can occur,
        during inference/generation step of the neural networks.

First of all, you have to provide actual input via recurrent states,
        since the input of RecurrentNetwork should be known in advance.
        Here, we use `fake_inputs` as the input,
        and it's used by the op to extract batch size and sequence length.
        The actual input sequence is stored in the recurrent state
        `input_state`. At every step we generate a new element via input_state_t
        (in this example, input_state_t is generated at random, but
        in a real situation it can be created using convolution output
        from the previous step).

A few important differences from regular RecurrentNetwork usecase:

1. input_state_t_prev is not only a single previous element of
        input_state sequence. It is last conv_window elements including (!)
        the current one - input_state_t. We specify that using `link_window`
        argument of RecurrentNetwork. We need that many elements to
        compute a single convolution step. Also, note that `link_window`
        specifies how many elements to link starting at
        `timestep` + `link_offset` position.

2. First few steps might require additional zero padding from the left,
        since there is no enough element of input_state sequence are available.
        So the initial_state for input_state contains several elements
        (exactly how many pads we need for the first step). Also, because of
        that all offseting over input_state sequence is being shifted
        by length of initial_input_state: see `link_offset` and `alias_offset`
        arguments of RecurrentNetwork.

In this test, we assert that we get the same result
        if we apply convolution over all elements simultaneously,
        since the whole input_state sequence was generated at the end.
    '''
        model = ModelHelper(name='model')
        fake_inputs = model.param_init_net.UniformFill(
            [],
            'fake_inputs',
            min=-1.0,
            max=1.0,
            shape=[sequence_length, batch_size, state_size],
        )
        initial_input_state = model.param_init_net.ConstantFill(
            [],
            'initial_input_state',
            value=0.0,
            shape=[conv_window - 1, batch_size, state_size],
        )
        initial_output_state = model.param_init_net.ConstantFill(
            [],
            'initial_output_state',
            value=0.0,
            shape=[1, batch_size, state_size],
        )
        step_model = ModelHelper(name='step_model', param_model=model)
        (
            fake_input_t,
            timestep,
            input_state_t_prev,
        ) = step_model.net.AddExternalInputs(
            'fake_input_t',
            'timestep',
            'input_state_t_prev',
        )
        conv_filter = step_model.param_init_net.XavierFill(
            [],
            'conv_filter',
            shape=[state_size, 1, conv_window, state_size],
        )
        conv_bias = step_model.param_init_net.ConstantFill(
            [],
            'conv_bias',
            shape=[state_size],
            value=0.0,
        )
        step_model.params.extend([conv_filter, conv_bias])
        input_state_t = step_model.net.UniformFill(
            [],
            'input_state_t',
            min=-1.0,
            max=1.0,
            shape=[1, batch_size, state_size],
        )
        output_state_t = self._convolution_1d(
            model=step_model,
            inputs=input_state_t_prev,
            conv_window=conv_window,
            conv_filter=conv_filter,
            conv_bias=conv_bias,
            output_name='output_state_t',
            left_pad=False,
        )
        initial_recurrent_states = [initial_input_state, initial_output_state]
        all_inputs = (
            [fake_inputs] + step_model.params + initial_recurrent_states
        )
        all_outputs = ['input_state_all', 'output_state_all']
        recurrent_states = ['input_state', 'output_state']
        input_state_all, output_state_all, _ = model.net.RecurrentNetwork(
            all_inputs,
            all_outputs + ['step_workspaces'],
            param=[all_inputs.index(p) for p in step_model.params],
            alias_src=recurrent_states,
            alias_dst=all_outputs,
            alias_offset=[conv_window - 1, 1],
            recurrent_states=recurrent_states,
            initial_recurrent_state_ids=[
                all_inputs.index(s) for s in initial_recurrent_states
            ],
            link_internal=[
                str(input_state_t_prev),
                str(input_state_t),
                str(output_state_t),
            ],
            link_external=['input_state', 'input_state', 'output_state'],
            link_offset=[0, conv_window - 1, 1],
            link_window=[conv_window, 1, 1],
            backward_link_internal=[],
            backward_link_external=[],
            backward_link_offset=[],
            step_net=step_model.net.Proto(),
            timestep='timestep' if timestep is None else str(timestep),
            outputs_with_grads=[],
        )

output_states_2 = self._convolution_1d(
            model=model,
            inputs=input_state_all,
            conv_window=conv_window,
            conv_filter=conv_filter,
            conv_bias=conv_bias,
            output_name='output_states_2',
            left_pad=True,
        )

workspace.RunNetOnce(model.param_init_net)
        workspace.RunNetOnce(model.net)

np.testing.assert_almost_equal(
            workspace.FetchBlob(output_state_all),
            workspace.FetchBlob(output_states_2),
            decimal=3,
        )

cmd: