├── dir_base.py ├── README.md ├── simple_cnn_impl.py ├── test_ConvLSTM_ConvGRU.py ├── .gitignore ├── predict_and_draw.py ├── radar_forecast.py ├── ConvGRUCell.py ├── generate_lstm_data.py ├── read_radar.py ├── ConvLSTMCell.py ├── test_LSTM.py ├── rough.py ├── recurrent_network.py ├── conv_lstm.py ├── dynamic_rnn.py ├── rnn_cell_impl.py └── file_list /dir_base.py: -------------------------------------------------------------------------------- 1 | from tensorflow.python.layers import base as base_layer 2 | 3 | print(dir(base_layer.Layer)) 4 | print(dir(base_layer.Layer())) 5 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Conv-LSTM 2 | based on this paper: [Convolutional LSTM Network: A Machine Learning Approach for Precipitation Nowcasting](https://arxiv.org/abs/1506.04214) 3 | 4 | read_radar: read radar data and save it to numpy format. 5 | 6 | radar_forecast build the ConvLSTM network and train. 7 | 8 | predict_and_draw draw the nowcasting results. 9 | -------------------------------------------------------------------------------- /simple_cnn_impl.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | 3 | import matplotlib.pyplot as plt 4 | import numpy as np 5 | import tensorflow as tf 6 | from tensorflow.contrib.learn.python.learn.datasets.mnist import read_data_sets 7 | 8 | 9 | def main(): 10 | # load data 11 | data_dir = 'tmp' 12 | mnist = read 13 | with tf.Session() as sess: 14 | 15 | 16 | if __name__ == '__main__': 17 | main() 18 | 19 | -------------------------------------------------------------------------------- /test_ConvLSTM_ConvGRU.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | 3 | import tensorflow as tf 4 | import numpy as np 5 | 6 | from generate_lstm_data import generate_movies 7 | 8 | batch_size = 10 9 | timesteps = 15 10 | shape = [40, 40] 11 | kernel = [3, 3] 12 | channels = 1 13 | filters = 12 14 | 15 | # Create a placeholder for videos. 16 | inputs = tf.placeholder(tf.float32, [batch_size, timesteps] + shape + [channels]) 17 | print(inputs) 18 | noisy_movies, shifted_movies = generate_movies() 19 | print(np.shape(noisy_movies)) 20 | 21 | # Add the ConvLSTM step. 22 | from ConvLSTMCell import ConvLSTMCell 23 | cell = ConvLSTMCell(shape, filters, kernel) 24 | outputs, state = tf.nn.dynamic_rnn(cell, inputs, dtype=inputs.dtype) 25 | 26 | # There's also a ConvGRUCell that is more memory efficient. 27 | from ConvGRUCell import ConvGRUCell 28 | cell = ConvGRUCell(shape, filters, kernel) 29 | outputs, state = tf.nn.dynamic_rnn(cell, inputs, dtype=inputs.dtype) 30 | 31 | # It's also possible to enter 2D input or 4D input instead of 3D. 32 | shape = [100] 33 | kernel = [3] 34 | inputs = tf.placeholder(tf.float32, [batch_size, timesteps] + shape + [channels]) 35 | cell = ConvLSTMCell(shape, filters, kernel) 36 | outputs, state = tf.nn.bidirectional_dynamic_rnn(cell, cell, inputs, dtype=inputs.dtype) 37 | 38 | shape = [50, 50, 50] 39 | kernel = [1, 3, 5] 40 | inputs = tf.placeholder(tf.float32, [batch_size, timesteps] + shape + [channels]) 41 | cell = ConvGRUCell(shape, filters, kernel) 42 | outputs, state= tf.nn.bidirectional_dynamic_rnn(cell, cell, inputs, dtype=inputs.dtype) 43 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | env/ 12 | build/ 13 | develop-eggs/ 14 | dist/ 15 | downloads/ 16 | eggs/ 17 | .eggs/ 18 | lib/ 19 | lib64/ 20 | parts/ 21 | sdist/ 22 | var/ 23 | wheels/ 24 | *.egg-info/ 25 | .installed.cfg 26 | *.egg 27 | 28 | # PyInstaller 29 | # Usually these files are written by a python script from a template 30 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 31 | *.manifest 32 | *.spec 33 | 34 | # Installer logs 35 | pip-log.txt 36 | pip-delete-this-directory.txt 37 | 38 | # Unit test / coverage reports 39 | htmlcov/ 40 | .tox/ 41 | .coverage 42 | .coverage.* 43 | .cache 44 | nosetests.xml 45 | coverage.xml 46 | *.cover 47 | .hypothesis/ 48 | 49 | # Translations 50 | *.mo 51 | *.pot 52 | 53 | # Django stuff: 54 | *.log 55 | local_settings.py 56 | 57 | # Flask stuff: 58 | instance/ 59 | .webassets-cache 60 | 61 | # Scrapy stuff: 62 | .scrapy 63 | 64 | # Sphinx documentation 65 | docs/_build/ 66 | 67 | # PyBuilder 68 | target/ 69 | 70 | # Jupyter Notebook 71 | .ipynb_checkpoints 72 | 73 | # pyenv 74 | .python-version 75 | 76 | # celery beat schedule file 77 | celerybeat-schedule 78 | 79 | # SageMath parsed files 80 | *.sage.py 81 | 82 | # dotenv 83 | .env 84 | 85 | # virtualenv 86 | .venv 87 | venv/ 88 | ENV/ 89 | 90 | # Spyder project settings 91 | .spyderproject 92 | .spyproject 93 | 94 | # Rope project settings 95 | .ropeproject 96 | 97 | # mkdocs documentation 98 | /site 99 | 100 | # mypy 101 | .mypy_cache/ 102 | -------------------------------------------------------------------------------- /predict_and_draw.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | 3 | import numpy as np 4 | import pylab as plt 5 | 6 | from keras.models import load_model 7 | from read_radar import read_radar 8 | 9 | def main(): 10 | 11 | model = load_model('./ConvLSTM.h5') 12 | 13 | rawdir = './fsl_20161018-22' 14 | data_set = read_radar(rawdir) 15 | data_set.generate_radarfsl() 16 | noisy_movies, shifted_movies = data_set.train_data, data_set.shifted_data 17 | 18 | # Testing the network on one movie 19 | # feed it with the first 7 positions and then 20 | # predict the new positions 21 | which = 40 22 | track = noisy_movies[which][:7, ::, ::, ::] 23 | 24 | for j in range(25): 25 | new_pos = model.predict(track[np.newaxis, ::, ::, ::, ::]) 26 | new = new_pos[::, -1, ::, ::, ::] 27 | track = np.concatenate((track, new), axis=0) 28 | 29 | # And then compare the predictions 30 | # to the ground truth 31 | track2 = noisy_movies[which][::, ::, ::, ::] 32 | for i in range(24): 33 | fig = plt.figure(figsize=(10, 5)) 34 | 35 | ax = fig.add_subplot(121) 36 | 37 | if i >= 7: 38 | ax.text(1, 3, 'Predictions !', fontsize=20, color='w') 39 | else: 40 | ax.text(1, 3, 'Inital trajectory', fontsize=20) 41 | 42 | toplot = track[i, ::, ::, 0] 43 | 44 | plt.imshow(toplot) 45 | ax = fig.add_subplot(122) 46 | plt.text(1, 3, 'Ground truth', fontsize=20) 47 | 48 | toplot = track2[i, ::, ::, 0] 49 | if i >= 2: 50 | toplot = shifted_movies[which][i - 1, ::, ::, 0] 51 | 52 | plt.imshow(toplot) 53 | plt.savefig('%i_animate.png' % (i + 1)) 54 | 55 | if __name__ == '__main__': 56 | main() 57 | -------------------------------------------------------------------------------- /radar_forecast.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | 3 | from read_radar import read_radar 4 | 5 | import numpy as np 6 | 7 | from keras.models import Sequential 8 | from keras.layers.convolutional import Conv3D 9 | from keras.layers.convolutional_recurrent import ConvLSTM2D 10 | from keras.layers.normalization import BatchNormalization 11 | 12 | def main(): 13 | rawdir = './fsl_20161018-22' 14 | data_set = read_radar(rawdir) 15 | data_set.generate_radarfsl() 16 | n_pixel = 30 17 | 18 | seq = Sequential() 19 | seq.add(ConvLSTM2D(filters=n_pixel, kernel_size=(3, 3), 20 | input_shape=(None, n_pixel, n_pixel, 1), 21 | padding='same', return_sequences=True)) 22 | seq.add(BatchNormalization()) 23 | 24 | seq.add(ConvLSTM2D(filters=n_pixel, kernel_size=(3, 3), 25 | padding='same', return_sequences=True)) 26 | seq.add(BatchNormalization()) 27 | 28 | seq.add(ConvLSTM2D(filters=n_pixel, kernel_size=(3, 3), 29 | padding='same', return_sequences=True)) 30 | seq.add(BatchNormalization()) 31 | 32 | seq.add(ConvLSTM2D(filters=n_pixel, kernel_size=(3, 3), 33 | padding='same', return_sequences=True)) 34 | seq.add(BatchNormalization()) 35 | 36 | seq.add(Conv3D(filters=1, kernel_size=(3, 3, 3), 37 | activation='sigmoid', 38 | padding='same', data_format='channels_last')) 39 | 40 | seq.compile(loss='mean_squared_error', optimizer='adadelta') 41 | 42 | # Train the network 43 | noisy_movies, shifted_movies = data_set.train_data, data_set.shifted_data 44 | seq.fit(noisy_movies[:1000], shifted_movies[:1000], batch_size=10, 45 | epochs=50, validation_split=0.05) 46 | 47 | #save model 48 | seq.save('ConvLSTM.h5') 49 | 50 | if __name__ == '__main__': 51 | main() 52 | 53 | -------------------------------------------------------------------------------- /ConvGRUCell.py: -------------------------------------------------------------------------------- 1 | import tensorflow as tf 2 | 3 | class ConvGRUCell(tf.nn.rnn_cell.RNNCell): 4 | """A GRU cell with convolutions instead of multiplications.""" 5 | 6 | def __init__(self, shape, filters, kernel, activation=tf.tanh, normalize=True, data_format='channels_last', reuse=None): 7 | super(ConvGRUCell, self).__init__(_reuse=reuse) 8 | self._filters = filters 9 | self._kernel = kernel 10 | self._activation = activation 11 | self._normalize = normalize 12 | if data_format == 'channels_last': 13 | self._size = tf.TensorShape(shape + [self._filters]) 14 | self._feature_axis = self._size.ndims 15 | self._data_format = None 16 | elif data_format == 'channels_first': 17 | self._size = tf.TensorShape([self._filters] + shape) 18 | self._feature_axis = 0 19 | self._data_format = 'NC' 20 | else: 21 | raise ValueError('Unknown data_format') 22 | 23 | @property 24 | def state_size(self): 25 | return self._size 26 | 27 | @property 28 | def output_size(self): 29 | return self._size 30 | 31 | def call(self, x, h): 32 | channels = x.shape[self._feature_axis].value 33 | 34 | with tf.variable_scope('gates'): 35 | inputs = tf.concat([x, h], axis=self._feature_axis) 36 | n = channels + self._filters 37 | m = 2 * self._filters if self._filters > 1 else 2 38 | W = tf.get_variable('kernel', self._kernel + [n, m]) 39 | y = tf.nn.convolution(inputs, W, 'SAME', data_format=self._data_format) 40 | if self._normalize: 41 | r, u = tf.split(y, 2, axis=self._feature_axis) 42 | r = tf.contrib.layers.layer_norm(r) 43 | u = tf.contrib.layers.layer_norm(u) 44 | else: 45 | y += tf.get_variable('bias', [m], initializer=tf.ones_initializer()) 46 | r, u = tf.split(y, 2, axis=self._feature_axis) 47 | r, u = tf.sigmoid(r), tf.sigmoid(u) 48 | 49 | # TODO 50 | #tf.summary.histogram('reset_gate', r) 51 | #tf.summary.histogram('update_gate', u) 52 | 53 | with tf.variable_scope('candidate'): 54 | inputs = tf.concat([x, r * h], axis=self._feature_axis) 55 | n = channels + self._filters 56 | m = self._filters 57 | W = tf.get_variable('kernel', self._kernel + [n, m]) 58 | y = tf.nn.convolution(inputs, W, 'SAME', data_format=self._data_format) 59 | if self._normalize: 60 | y = tf.contrib.layers.layer_norm(y) 61 | else: 62 | y += tf.get_variable('bias', [m], initializer=tf.zeros_initializer()) 63 | h = u * h + (1 - u) * self._activation(y) 64 | 65 | return h, h 66 | -------------------------------------------------------------------------------- /generate_lstm_data.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | 3 | class generate_sin_datas(object): 4 | 5 | def __init__(self, batch_size=128, n_input=1000): 6 | self.batch_size = batch_size 7 | self.n_input = n_input 8 | 9 | def next_batch(self): 10 | datas = np.ndarray(shape=(self.batch_size, self.n_input)) 11 | datas[:,0] = 10 * np.random.rand(self.batch_size) 12 | for i, val in enumerate(datas[:,0]): 13 | datas[i,:] = np.sin(np.linspace(val, val+100, self.n_input, dtype=np.float32)) 14 | x = datas[:,0:-1] 15 | y = datas[:,-1] 16 | return x, y 17 | 18 | def generate_movies(batch_size=10,shape=[80,80], n_frames=15): 19 | row, col = shape 20 | noisy_movies = np.zeros((batch_size, n_frames, row, col, 1), dtype=np.float) 21 | shifted_movies = np.zeros((batch_size, n_frames, row, col, 1), 22 | dtype=np.float) 23 | 24 | for i in range(batch_size): 25 | # Add 3 to 7 moving squares 26 | n = np.random.randint(3, 8) 27 | 28 | for j in range(n): 29 | # Initial position 30 | xstart = np.random.randint(20, 60) 31 | ystart = np.random.randint(20, 60) 32 | # Direction of motion 33 | directionx = np.random.randint(0, 3) - 1 34 | directiony = np.random.randint(0, 3) - 1 35 | 36 | # Size of the square 37 | w = np.random.randint(2, 4) 38 | 39 | for t in range(n_frames): 40 | x_shift = xstart + directionx * t 41 | y_shift = ystart + directiony * t 42 | noisy_movies[i, t, x_shift - w: x_shift + w, 43 | y_shift - w: y_shift + w, 0] += 1 44 | 45 | # Make it more robust by adding noise. 46 | # The idea is that if during inference, 47 | # the value of the pixel is not exactly one, 48 | # we need to train the network to be robust and still 49 | # consider it as a pixel belonging to a square. 50 | if np.random.randint(0, 2): 51 | noise_f = (-1)**np.random.randint(0, 2) 52 | noisy_movies[i, t, 53 | x_shift - w - 1: x_shift + w + 1, 54 | y_shift - w - 1: y_shift + w + 1, 55 | 0] += noise_f * 0.1 56 | 57 | # Shift the ground truth by 1 58 | x_shift = xstart + directionx * (t + 1) 59 | y_shift = ystart + directiony * (t + 1) 60 | shifted_movies[i, t, x_shift - w: x_shift + w, 61 | y_shift - w: y_shift + w, 0] += 1 62 | 63 | # Cut to a 40x40 window 64 | noisy_movies = noisy_movies[::, ::, 20:60, 20:60, ::] 65 | shifted_movies = shifted_movies[::, ::, 20:60, 20:60, ::] 66 | noisy_movies[noisy_movies >= 1] = 1 67 | shifted_movies[shifted_movies >= 1] = 1 68 | return noisy_movies, shifted_movies 69 | -------------------------------------------------------------------------------- /read_radar.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | 3 | import time 4 | import os 5 | 6 | import numpy as np 7 | 8 | class read_radar(object): 9 | 10 | def __init__(self, data_dir): 11 | self.rawdir = data_dir 12 | self.saved_file_name = 'rawdata.npz' 13 | self.ntimes = 0 14 | self.row = None 15 | self.col = None 16 | self.shift_len = 1 17 | self.train_data = None 18 | self.shifted_data = None 19 | 20 | def read_file(self, file_name): 21 | print('Run task %s (%s)...' % (file_name, os.getpid())) 22 | start = time.time() 23 | file_data = [] 24 | with open(file_name) as f: 25 | line = f.readline() 26 | while line: 27 | line = line.strip('\n') 28 | file_data.append(line.split(',')) 29 | line = f.readline() 30 | end = time.time() 31 | print('Task %s runs %0.2f seconds.' % (file_name, (end - start))) 32 | return np.array(file_data, dtype=float)[40:70, 40:70] 33 | 34 | def generate_radarfsl(self): 35 | if os.path.isfile(self.saved_file_name): 36 | self.loadArray() 37 | else: 38 | datas = [] 39 | with open('./file_list', 'r') as file_list: 40 | for line in file_list.readlines(): 41 | line = line.strip('\n') 42 | file_name = os.path.join(self.rawdir, line) 43 | d = self.read_file(file_name) 44 | datas.append(d) 45 | self.ntimes += 1 46 | 47 | datas_array = np.array(datas) 48 | 49 | self.row, self.col = np.shape(datas[0])[0], np.shape(datas[0])[1] 50 | 51 | self.train_data = np.zeros((self.ntimes-24, 24, 52 | self.row, self.col, 1)) 53 | 54 | self.shifted_data = np.zeros((self.ntimes-24, 24, 55 | self.row, self.col, 1)) 56 | 57 | print(np.shape(self.train_data)) 58 | print(np.shape(self.shifted_data)) 59 | 60 | for i in range(24): 61 | print(i) 62 | self.train_data[:,i,:,:,0] = datas_array[i:i+self.ntimes-24] 63 | self.shifted_data[:,i,:,:,0] = datas_array[i+1:i+1+self.ntimes-24] 64 | 65 | # self.train_data[self.train_data < 3] = 0 66 | # self.shifted_data[self.shifted_data < 3] = 0 67 | self.shifted_data = self.shifted_data / 9.0 68 | self.train_data = self.train_data / 9.0 69 | 70 | self.saveArray() 71 | 72 | def saveArray(self): 73 | np.savez(self.saved_file_name , X=self.train_data, 74 | y=self.shifted_data) 75 | 76 | def loadArray(self): 77 | print('reading datas from saved file') 78 | arch = np.load(self.saved_file_name) 79 | self.train_data = arch['X'] 80 | self.shifted_data = arch['y'] 81 | print('end reading data') 82 | print(np.shape(self.train_data)) 83 | print(np.shape(self.shifted_data)) 84 | 85 | 86 | if __name__ == '__main__': 87 | rawdir = 'fsl_20161018-22' 88 | data_set = read_radar(rawdir) 89 | data_set.generate_radarfsl() 90 | 91 | -------------------------------------------------------------------------------- /ConvLSTMCell.py: -------------------------------------------------------------------------------- 1 | import tensorflow as tf 2 | 3 | class ConvLSTMCell(tf.nn.rnn_cell.RNNCell): 4 | """A LSTM cell with convolutions instead of multiplications. 5 | 6 | Reference: 7 | Xingjian, S. H. I., et al. "Convolutional LSTM network: A machine learning approach for precipitation nowcasting." Advances in Neural Information Processing Systems. 2015. 8 | """ 9 | 10 | def __init__(self, shape, filters, kernel, forget_bias=1.0,\ 11 | activation=tf.tanh, normalize=True, peephole=True,\ 12 | data_format='channels_last', reuse=None): 13 | super(ConvLSTMCell, self).__init__(_reuse=reuse) 14 | self._kernel = kernel 15 | self._filters = filters 16 | self._forget_bias = forget_bias 17 | self._activation = activation 18 | self._normalize = normalize 19 | self._peephole = peephole 20 | if data_format == 'channels_last': 21 | self._size = tf.TensorShape(shape + [self._filters]) 22 | self._feature_axis = self._size.ndims 23 | self._data_format = None 24 | elif data_format == 'channels_first': 25 | self._size = tf.TensorShape([self._filters] + shape) 26 | self._feature_axis = 0 27 | self._data_format = 'NC' 28 | else: 29 | raise ValueError('Unknown data_format') 30 | 31 | @property 32 | def state_size(self): 33 | return tf.nn.rnn_cell.LSTMStateTuple(self._size, self._size) 34 | 35 | @property 36 | def output_size(self): 37 | return self._size 38 | 39 | def call(self, x, state): 40 | # c: cell h: final state 41 | c, h = state 42 | 43 | x = tf.concat([x, h], axis=self._feature_axis) 44 | n = x.shape[-1].value 45 | m = 4 * self._filters if self._filters > 1 else 4 46 | W = tf.get_variable('kernel', self._kernel + [n, m]) 47 | y = tf.nn.convolution(x, W, 'SAME', data_format=self._data_format) 48 | 49 | if not self._normalize: 50 | y += tf.get_variable('bias', [m], initializer=tf.zeros_initializer()) 51 | j, i, f, o = tf.split(y, 4, axis=self._feature_axis) 52 | 53 | if self._peephole: 54 | i += tf.get_variable('W_ci', c.shape[1:]) * c 55 | f += tf.get_variable('W_cf', c.shape[1:]) * c 56 | 57 | if self._normalize: 58 | j = tf.contrib.layers.layer_norm(j) 59 | i = tf.contrib.layers.layer_norm(i) 60 | f = tf.contrib.layers.layer_norm(f) 61 | 62 | f = tf.sigmoid(f + self._forget_bias) 63 | i = tf.sigmoid(i) 64 | new_c = c * f + i * self._activation(j) 65 | 66 | if self._peephole: 67 | o += tf.get_variable('W_co', c.shape[1:]) * c 68 | 69 | if self._normalize: 70 | o = tf.contrib.layers.layer_norm(o) 71 | c = tf.contrib.layers.layer_norm(c) 72 | 73 | o = tf.sigmoid(o) 74 | new_h = o * self._activation(c) 75 | 76 | # TODO 77 | #tf.summary.histogram('forget_gate', f) 78 | #tf.summary.histogram('input_gate', i) 79 | #tf.summary.histogram('output_gate', o) 80 | #tf.summary.histogram('cell_state', c) 81 | 82 | new_state = tf.nn.rnn_cell.LSTMStateTuple(new_c, new_h) 83 | 84 | return new_h, new_state 85 | -------------------------------------------------------------------------------- /test_LSTM.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | 3 | from __future__ import print_function 4 | 5 | import tensorflow as tf 6 | from tensorflow.contrib import rnn 7 | from generate_lstm_data import generate_sin_datas 8 | import numpy as np 9 | 10 | # parameters 11 | learning_rate = 0.001 12 | training_iters = 100000 13 | batch_size = 128 14 | display_step = 10 15 | 16 | 17 | # network parameters 18 | n_input = 1 19 | n_steps = 999 20 | n_classes = 1 21 | n_hidden = 128 22 | 23 | gen = generate_sin_datas() 24 | x, y = gen.next_batch() 25 | 26 | # tf Graph input 27 | x = tf.placeholder("float", [None, n_steps, n_input]) 28 | y = tf.placeholder("float", [None, 1]) 29 | 30 | # Define weights 31 | weights = { 32 | 'out': tf.Variable(tf.random_normal([n_hidden, n_classes])) 33 | } 34 | biases = { 35 | 'out': tf.Variable(tf.random_normal([n_classes])) 36 | } 37 | 38 | def RNN(x, weights, biases): 39 | 40 | # Prepare data shape to match `rnn` function requirements 41 | # Current data input shape: (batch_size, n_steps, n_input) 42 | # Required shape: 'n_steps' tensors list of shape (batch_size, n_input) 43 | 44 | # Unstack to get a list of 'n_steps' tensors of shape (batch_size, n_input) 45 | x = tf.unstack(x, n_steps, 1) 46 | 47 | # Define a lstm cell with tensorflow 48 | lstm_cell = rnn.BasicLSTMCell(n_hidden, forget_bias=1.0) 49 | 50 | # Get lstm cell output 51 | outputs, states = rnn.static_rnn(lstm_cell, x, dtype=tf.float32) 52 | 53 | # Linear activation, using rnn inner loop last output 54 | return tf.matmul(outputs[-1], weights['out']) + biases['out'] 55 | 56 | pred = RNN(x, weights, biases) 57 | 58 | # Define loss and optimizer 59 | cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y)) 60 | optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost) 61 | 62 | # Evaluate model 63 | correct_pred = tf.equal(tf.argmax(pred,1), tf.argmax(y,1)) 64 | accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32)) 65 | 66 | # Initializing the variables 67 | init = tf.global_variables_initializer() 68 | 69 | # Launch the graph 70 | with tf.Session() as sess: 71 | sess.run(init) 72 | step = 1 73 | # Keep training until reach max iterations 74 | while step * batch_size < training_iters: 75 | batch_x, batch_y = gen.__next__() 76 | # Reshape data to get 28 seq of 28 elements 77 | batch_x = batch_x.reshape((batch_size, n_steps, n_input)) 78 | # Run optimization op (backprop) 79 | sess.run(optimizer, feed_dict={x: batch_x, y: batch_y}) 80 | if step % display_step == 0: 81 | # Calculate batch accuracy 82 | acc = sess.run(accuracy, feed_dict={x: batch_x, y: batch_y}) 83 | # Calculate batch loss 84 | loss = sess.run(cost, feed_dict={x: batch_x, y: batch_y}) 85 | print("Iter " + str(step*batch_size) + ", Minibatch Loss= " + \ 86 | "{:.6f}".format(loss) + ", Training Accuracy= " + \ 87 | "{:.5f}".format(acc)) 88 | step += 1 89 | print("Optimization Finished!") 90 | 91 | # Calculate accuracy for 128 mnist test images 92 | test_len = 128 93 | test_data = mnist.test.images[:test_len].reshape((-1, n_steps, n_input)) 94 | test_label = mnist.test.labels[:test_len] 95 | print("Testing Accuracy:", \ 96 | sess.run(accuracy, feed_dict={x: test_data, y: test_label})) 97 | -------------------------------------------------------------------------------- /rough.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | 3 | import time 4 | import os 5 | 6 | import numpy as np 7 | 8 | class read_radar(object): 9 | 10 | def __init__(self, data_dir): 11 | self.rawdir = data_dir 12 | self.saved_file_name = 'rawdata.npz' 13 | self.ntimes = 0 14 | self.row = None 15 | self.col = None 16 | self.row_rough = 50 17 | self.col_rough = 50 18 | self.shift_len = 1 19 | self.train_data = None 20 | self.shifted_data = None 21 | 22 | def read_file(self, file_name): 23 | print('Run task %s (%s)...' % (file_name, os.getpid())) 24 | start = time.time() 25 | file_data = [] 26 | with open(file_name) as f: 27 | line = f.readline() 28 | while line: 29 | line = line.strip('\n') 30 | file_data.append(line.split(',')) 31 | line = f.readline() 32 | end = time.time() 33 | print('Task %s runs %0.2f seconds.' % (file_name, (end - start))) 34 | array_ori = np.array(file_data, dtype=float) 35 | array_rough = np.zeros((self.row_rough, self.col_rough)) 36 | for i in range(self.row_rough): 37 | for j in range(self.col_rough): 38 | array_rough[i, j] = np.mean(array_ori[5*i:5*i+4,5*j:5*j+4]) 39 | return array_rough[10:40, 10:40] 40 | 41 | def generate_radarfsl(self): 42 | if os.path.isfile(self.saved_file_name): 43 | self.loadArray() 44 | else: 45 | datas = [] 46 | with open('./file_list', 'r') as file_list: 47 | for line in file_list.readlines(): 48 | line = line.strip('\n') 49 | file_name = os.path.join(self.rawdir, line) 50 | d = self.read_file(file_name) 51 | datas.append(d) 52 | self.ntimes += 1 53 | 54 | datas_array = np.array(datas) 55 | 56 | self.row, self.col = np.shape(datas[0])[0], np.shape(datas[0])[1] 57 | 58 | self.train_data = np.zeros((self.ntimes-24, 24, 59 | self.row, self.col, 1)) 60 | 61 | self.shifted_data = np.zeros((self.ntimes-24, 24, 62 | self.row, self.col, 1)) 63 | 64 | print(np.shape(self.train_data)) 65 | print(np.shape(self.shifted_data)) 66 | 67 | for i in range(24): 68 | print(i) 69 | self.train_data[:,i,:,:,0] = datas_array[i:i+self.ntimes-24] 70 | self.shifted_data[:,i,:,:,0] = datas_array[i+1:i+1+self.ntimes-24] 71 | 72 | self.shifted_data = self.shifted_data / 9.0 73 | self.train_data = self.train_data / 9.0 74 | 75 | self.saveArray() 76 | 77 | def saveArray(self): 78 | np.savez(self.saved_file_name , X=self.train_data, 79 | y=self.shifted_data) 80 | 81 | def loadArray(self): 82 | print('reading datas from saved file') 83 | arch = np.load(self.saved_file_name) 84 | self.train_data = arch['X'] 85 | self.shifted_data = arch['y'] 86 | print('end reading data') 87 | print(np.shape(self.train_data)) 88 | print(np.shape(self.shifted_data)) 89 | 90 | 91 | if __name__ == '__main__': 92 | rawdir = 'fsl_20161018-22' 93 | data_set = read_radar(rawdir) 94 | data_set.generate_radarfsl() 95 | 96 | -------------------------------------------------------------------------------- /recurrent_network.py: -------------------------------------------------------------------------------- 1 | ''' 2 | A Recurrent Neural Network (LSTM) implementation example using TensorFlow library. 3 | This example is using the MNIST database of handwritten digits (http://yann.lecun.com/exdb/mnist/) 4 | Long Short Term Memory paper: http://deeplearning.cs.cmu.edu/pdfs/Hochreiter97_lstm.pdf 5 | 6 | Author: Aymeric Damien 7 | Project: https://github.com/aymericdamien/TensorFlow-Examples/ 8 | ''' 9 | 10 | from __future__ import print_function 11 | 12 | import tensorflow as tf 13 | from tensorflow.contrib import rnn 14 | import numpy as np 15 | 16 | # Import MNIST data 17 | from tensorflow.examples.tutorials.mnist import input_data 18 | mnist = input_data.read_data_sets("/tmp/data/", one_hot=True) 19 | 20 | ''' 21 | To classify images using a recurrent neural network, we consider every image 22 | row as a sequence of pixels. Because MNIST image shape is 28*28px, we will then 23 | handle 28 sequences of 28 steps for every sample. 24 | ''' 25 | 26 | # Parameters 27 | learning_rate = 0.001 28 | training_iters = 100000 29 | batch_size = 128 30 | display_step = 10 31 | 32 | # Network Parameters 33 | n_input = 28 # MNIST data input (img shape: 28*28) 34 | n_steps = 28 # timesteps 35 | n_hidden = 128 # hidden layer num of features 36 | n_classes = 10 # MNIST total classes (0-9 digits) 37 | 38 | # tf Graph input 39 | x = tf.placeholder("float", [None, n_steps, n_input]) 40 | y = tf.placeholder("float", [None, n_classes]) 41 | 42 | # Define weights 43 | weights = { 44 | 'out': tf.Variable(tf.random_normal([n_hidden, n_classes])) 45 | } 46 | biases = { 47 | 'out': tf.Variable(tf.random_normal([n_classes])) 48 | } 49 | 50 | 51 | def RNN(x, weights, biases): 52 | 53 | # Prepare data shape to match `rnn` function requirements 54 | # Current data input shape: (batch_size, n_steps, n_input) 55 | # Required shape: 'n_steps' tensors list of shape (batch_size, n_input) 56 | 57 | # Unstack to get a list of 'n_steps' tensors of shape (batch_size, n_input) 58 | x = tf.unstack(x, n_steps, 1) 59 | 60 | # Define a lstm cell with tensorflow 61 | lstm_cell = rnn.BasicLSTMCell(n_hidden, forget_bias=1.0) 62 | 63 | # Get lstm cell output 64 | outputs, states = rnn.static_rnn(lstm_cell, x, dtype=tf.float32) 65 | 66 | # Linear activation, using rnn inner loop last output 67 | return tf.matmul(outputs[-1], weights['out']) + biases['out'] 68 | 69 | pred = RNN(x, weights, biases) 70 | 71 | # Define loss and optimizer 72 | cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y)) 73 | optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost) 74 | 75 | # Evaluate model 76 | correct_pred = tf.equal(tf.argmax(pred,1), tf.argmax(y,1)) 77 | accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32)) 78 | 79 | # Initializing the variables 80 | init = tf.global_variables_initializer() 81 | 82 | # Launch the graph 83 | with tf.Session() as sess: 84 | sess.run(init) 85 | step = 1 86 | # Keep training until reach max iterations 87 | while step * batch_size < training_iters: 88 | batch_x, batch_y = mnist.train.next_batch(batch_size) 89 | # Reshape data to get 28 seq of 28 elements 90 | batch_x = batch_x.reshape((batch_size, n_steps, n_input)) 91 | print(np.shape(batch_x)) 92 | # Run optimization op (backprop) 93 | sess.run(optimizer, feed_dict={x: batch_x, y: batch_y}) 94 | if step % display_step == 0: 95 | # Calculate batch accuracy 96 | acc = sess.run(accuracy, feed_dict={x: batch_x, y: batch_y}) 97 | # Calculate batch loss 98 | loss = sess.run(cost, feed_dict={x: batch_x, y: batch_y}) 99 | print("Iter " + str(step*batch_size) + ", Minibatch Loss= " + \ 100 | "{:.6f}".format(loss) + ", Training Accuracy= " + \ 101 | "{:.5f}".format(acc)) 102 | step += 1 103 | print("Optimization Finished!") 104 | 105 | # Calculate accuracy for 128 mnist test images 106 | test_len = 128 107 | test_data = mnist.test.images[:test_len].reshape((-1, n_steps, n_input)) 108 | test_label = mnist.test.labels[:test_len] 109 | print("Testing Accuracy:", \ 110 | sess.run(accuracy, feed_dict={x: test_data, y: test_label})) 111 | -------------------------------------------------------------------------------- /conv_lstm.py: -------------------------------------------------------------------------------- 1 | """ This script demonstrates the use of a convolutional LSTM network. 2 | This network is used to predict the next frame of an artificially 3 | generated movie which contains moving squares. 4 | """ 5 | from keras.models import Sequential 6 | from keras.layers.convolutional import Conv3D 7 | from keras.layers.convolutional_recurrent import ConvLSTM2D 8 | from keras.layers.normalization import BatchNormalization 9 | import numpy as np 10 | import pylab as plt 11 | 12 | # We create a layer which take as input movies of shape 13 | # (n_frames, width, height, channels) and returns a movie 14 | # of identical shape. 15 | 16 | seq = Sequential() 17 | seq.add(ConvLSTM2D(filters=40, kernel_size=(3, 3), 18 | input_shape=(None, 40, 40, 1), 19 | padding='same', return_sequences=True)) 20 | seq.add(BatchNormalization()) 21 | 22 | seq.add(ConvLSTM2D(filters=40, kernel_size=(3, 3), 23 | padding='same', return_sequences=True)) 24 | seq.add(BatchNormalization()) 25 | 26 | seq.add(ConvLSTM2D(filters=40, kernel_size=(3, 3), 27 | padding='same', return_sequences=True)) 28 | seq.add(BatchNormalization()) 29 | 30 | seq.add(ConvLSTM2D(filters=40, kernel_size=(3, 3), 31 | padding='same', return_sequences=True)) 32 | seq.add(BatchNormalization()) 33 | 34 | seq.add(Conv3D(filters=1, kernel_size=(3, 3, 3), 35 | activation='sigmoid', 36 | padding='same', data_format='channels_last')) 37 | seq.compile(loss='binary_crossentropy', optimizer='adadelta') 38 | 39 | 40 | # Artificial data generation: 41 | # Generate movies with 3 to 7 moving squares inside. 42 | # The squares are of shape 1x1 or 2x2 pixels, 43 | # which move linearly over time. 44 | # For convenience we first create movies with bigger width and height (80x80) 45 | # and at the end we select a 40x40 window. 46 | 47 | def generate_movies(n_samples=1200, n_frames=15): 48 | row = 80 49 | col = 80 50 | noisy_movies = np.zeros((n_samples, n_frames, row, col, 1), dtype=np.float) 51 | shifted_movies = np.zeros((n_samples, n_frames, row, col, 1), 52 | dtype=np.float) 53 | 54 | for i in range(n_samples): 55 | # Add 3 to 7 moving squares 56 | n = np.random.randint(3, 8) 57 | 58 | for j in range(n): 59 | # Initial position 60 | xstart = np.random.randint(20, 60) 61 | ystart = np.random.randint(20, 60) 62 | # Direction of motion 63 | directionx = np.random.randint(0, 3) - 1 64 | directiony = np.random.randint(0, 3) - 1 65 | 66 | # Size of the square 67 | w = np.random.randint(2, 4) 68 | 69 | for t in range(n_frames): 70 | x_shift = xstart + directionx * t 71 | y_shift = ystart + directiony * t 72 | noisy_movies[i, t, x_shift - w: x_shift + w, 73 | y_shift - w: y_shift + w, 0] += 1 74 | 75 | # Make it more robust by adding noise. 76 | # The idea is that if during inference, 77 | # the value of the pixel is not exactly one, 78 | # we need to train the network to be robust and still 79 | # consider it as a pixel belonging to a square. 80 | if np.random.randint(0, 2): 81 | noise_f = (-1)**np.random.randint(0, 2) 82 | noisy_movies[i, t, 83 | x_shift - w - 1: x_shift + w + 1, 84 | y_shift - w - 1: y_shift + w + 1, 85 | 0] += noise_f * 0.1 86 | 87 | # Shift the ground truth by 1 88 | x_shift = xstart + directionx * (t + 1) 89 | y_shift = ystart + directiony * (t + 1) 90 | shifted_movies[i, t, x_shift - w: x_shift + w, 91 | y_shift - w: y_shift + w, 0] += 1 92 | 93 | # Cut to a 40x40 window 94 | noisy_movies = noisy_movies[::, ::, 20:60, 20:60, ::] 95 | shifted_movies = shifted_movies[::, ::, 20:60, 20:60, ::] 96 | noisy_movies[noisy_movies >= 1] = 1 97 | shifted_movies[shifted_movies >= 1] = 1 98 | return noisy_movies, shifted_movies 99 | 100 | # Train the network 101 | noisy_movies, shifted_movies = generate_movies(n_samples=1200) 102 | seq.fit(noisy_movies[:1000], shifted_movies[:1000], batch_size=10, 103 | epochs=300, validation_split=0.05) 104 | 105 | # Testing the network on one movie 106 | # feed it with the first 7 positions and then 107 | # predict the new positions 108 | which = 1004 109 | track = noisy_movies[which][:7, ::, ::, ::] 110 | 111 | for j in range(16): 112 | new_pos = seq.predict(track[np.newaxis, ::, ::, ::, ::]) 113 | new = new_pos[::, -1, ::, ::, ::] 114 | track = np.concatenate((track, new), axis=0) 115 | 116 | 117 | # And then compare the predictions 118 | # to the ground truth 119 | track2 = noisy_movies[which][::, ::, ::, ::] 120 | for i in range(15): 121 | fig = plt.figure(figsize=(10, 5)) 122 | 123 | ax = fig.add_subplot(121) 124 | 125 | if i >= 7: 126 | ax.text(1, 3, 'Predictions !', fontsize=20, color='w') 127 | else: 128 | ax.text(1, 3, 'Inital trajectory', fontsize=20) 129 | 130 | toplot = track[i, ::, ::, 0] 131 | 132 | plt.imshow(toplot) 133 | ax = fig.add_subplot(122) 134 | plt.text(1, 3, 'Ground truth', fontsize=20) 135 | 136 | toplot = track2[i, ::, ::, 0] 137 | if i >= 2: 138 | toplot = shifted_movies[which][i - 1, ::, ::, 0] 139 | 140 | plt.imshow(toplot) 141 | plt.savefig('%i_animate.png' % (i + 1)) 142 | -------------------------------------------------------------------------------- /dynamic_rnn.py: -------------------------------------------------------------------------------- 1 | ''' 2 | A Dynamic Recurrent Neural Network (LSTM) implementation example using 3 | TensorFlow library. This example is using a toy dataset to classify linear 4 | sequences. The generated sequences have variable length. 5 | 6 | Long Short Term Memory paper: http://deeplearning.cs.cmu.edu/pdfs/Hochreiter97_lstm.pdf 7 | 8 | Author: Aymeric Damien 9 | Project: https://github.com/aymericdamien/TensorFlow-Examples/ 10 | ''' 11 | 12 | from __future__ import print_function 13 | 14 | import tensorflow as tf 15 | import random 16 | 17 | 18 | # ==================== 19 | # TOY DATA GENERATOR 20 | # ==================== 21 | class ToySequenceData(object): 22 | """ Generate sequence of data with dynamic length. 23 | This class generate samples for training: 24 | - Class 0: linear sequences (i.e. [0, 1, 2, 3,...]) 25 | - Class 1: random sequences (i.e. [1, 3, 10, 7,...]) 26 | 27 | NOTICE: 28 | We have to pad each sequence to reach 'max_seq_len' for TensorFlow 29 | consistency (we cannot feed a numpy array with inconsistent 30 | dimensions). The dynamic calculation will then be perform thanks to 31 | 'seqlen' attribute that records every actual sequence length. 32 | """ 33 | def __init__(self, n_samples=1000, max_seq_len=20, min_seq_len=3, 34 | max_value=1000): 35 | self.data = [] 36 | self.labels = [] 37 | self.seqlen = [] 38 | for i in range(n_samples): 39 | # Random sequence length 40 | len = random.randint(min_seq_len, max_seq_len) 41 | # Monitor sequence length for TensorFlow dynamic calculation 42 | self.seqlen.append(len) 43 | # Add a random or linear int sequence (50% prob) 44 | if random.random() < .5: 45 | # Generate a linear sequence 46 | rand_start = random.randint(0, max_value - len) 47 | s = [[float(i)/max_value] for i in 48 | range(rand_start, rand_start + len)] 49 | # Pad sequence for dimension consistency 50 | s += [[0.] for i in range(max_seq_len - len)] 51 | self.data.append(s) 52 | self.labels.append([1., 0.]) 53 | else: 54 | # Generate a random sequence 55 | s = [[float(random.randint(0, max_value))/max_value] 56 | for i in range(len)] 57 | # Pad sequence for dimension consistency 58 | s += [[0.] for i in range(max_seq_len - len)] 59 | self.data.append(s) 60 | self.labels.append([0., 1.]) 61 | self.batch_id = 0 62 | 63 | def next(self, batch_size): 64 | """ Return a batch of data. When dataset end is reached, start over. 65 | """ 66 | if self.batch_id == len(self.data): 67 | self.batch_id = 0 68 | batch_data = (self.data[self.batch_id:min(self.batch_id + 69 | batch_size, len(self.data))]) 70 | batch_labels = (self.labels[self.batch_id:min(self.batch_id + 71 | batch_size, len(self.data))]) 72 | batch_seqlen = (self.seqlen[self.batch_id:min(self.batch_id + 73 | batch_size, len(self.data))]) 74 | self.batch_id = min(self.batch_id + batch_size, len(self.data)) 75 | return batch_data, batch_labels, batch_seqlen 76 | 77 | 78 | # ========== 79 | # MODEL 80 | # ========== 81 | 82 | # Parameters 83 | learning_rate = 0.01 84 | training_iters = 1000000 85 | batch_size = 128 86 | display_step = 10 87 | 88 | # Network Parameters 89 | seq_max_len = 20 # Sequence max length 90 | n_hidden = 64 # hidden layer num of features 91 | n_classes = 2 # linear sequence or not 92 | 93 | trainset = ToySequenceData(n_samples=1000, max_seq_len=seq_max_len) 94 | testset = ToySequenceData(n_samples=500, max_seq_len=seq_max_len) 95 | 96 | # tf Graph input 97 | x = tf.placeholder("float", [None, seq_max_len, 1]) 98 | y = tf.placeholder("float", [None, n_classes]) 99 | # A placeholder for indicating each sequence length 100 | seqlen = tf.placeholder(tf.int32, [None]) 101 | 102 | # Define weights 103 | weights = { 104 | 'out': tf.Variable(tf.random_normal([n_hidden, n_classes])) 105 | } 106 | biases = { 107 | 'out': tf.Variable(tf.random_normal([n_classes])) 108 | } 109 | 110 | 111 | def dynamicRNN(x, seqlen, weights, biases): 112 | 113 | # Prepare data shape to match `rnn` function requirements 114 | # Current data input shape: (batch_size, n_steps, n_input) 115 | # Required shape: 'n_steps' tensors list of shape (batch_size, n_input) 116 | 117 | # Unstack to get a list of 'n_steps' tensors of shape (batch_size, n_input) 118 | x = tf.unstack(x, seq_max_len, 1) 119 | 120 | # Define a lstm cell with tensorflow 121 | lstm_cell = tf.contrib.rnn.BasicLSTMCell(n_hidden) 122 | 123 | # Get lstm cell output, providing 'sequence_length' will perform dynamic 124 | # calculation. 125 | outputs, states = tf.contrib.rnn.static_rnn(lstm_cell, x, dtype=tf.float32, 126 | sequence_length=seqlen) 127 | 128 | # When performing dynamic calculation, we must retrieve the last 129 | # dynamically computed output, i.e., if a sequence length is 10, we need 130 | # to retrieve the 10th output. 131 | # However TensorFlow doesn't support advanced indexing yet, so we build 132 | # a custom op that for each sample in batch size, get its length and 133 | # get the corresponding relevant output. 134 | 135 | # 'outputs' is a list of output at every timestep, we pack them in a Tensor 136 | # and change back dimension to [batch_size, n_step, n_input] 137 | outputs = tf.stack(outputs) 138 | outputs = tf.transpose(outputs, [1, 0, 2]) 139 | 140 | # Hack to build the indexing and retrieve the right output. 141 | batch_size = tf.shape(outputs)[0] 142 | # Start indices for each sample 143 | index = tf.range(0, batch_size) * seq_max_len + (seqlen - 1) 144 | # Indexing 145 | outputs = tf.gather(tf.reshape(outputs, [-1, n_hidden]), index) 146 | 147 | # Linear activation, using outputs computed above 148 | return tf.matmul(outputs, weights['out']) + biases['out'] 149 | 150 | pred = dynamicRNN(x, seqlen, weights, biases) 151 | 152 | # Define loss and optimizer 153 | cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y)) 154 | optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(cost) 155 | 156 | # Evaluate model 157 | correct_pred = tf.equal(tf.argmax(pred,1), tf.argmax(y,1)) 158 | accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32)) 159 | 160 | # Initializing the variables 161 | init = tf.global_variables_initializer() 162 | 163 | # Launch the graph 164 | with tf.Session() as sess: 165 | sess.run(init) 166 | step = 1 167 | # Keep training until reach max iterations 168 | while step * batch_size < training_iters: 169 | batch_x, batch_y, batch_seqlen = trainset.next(batch_size) 170 | # Run optimization op (backprop) 171 | sess.run(optimizer, feed_dict={x: batch_x, y: batch_y, 172 | seqlen: batch_seqlen}) 173 | if step % display_step == 0: 174 | # Calculate batch accuracy 175 | acc = sess.run(accuracy, feed_dict={x: batch_x, y: batch_y, 176 | seqlen: batch_seqlen}) 177 | # Calculate batch loss 178 | loss = sess.run(cost, feed_dict={x: batch_x, y: batch_y, 179 | seqlen: batch_seqlen}) 180 | print("Iter " + str(step*batch_size) + ", Minibatch Loss= " + \ 181 | "{:.6f}".format(loss) + ", Training Accuracy= " + \ 182 | "{:.5f}".format(acc)) 183 | step += 1 184 | print("Optimization Finished!") 185 | 186 | # Calculate accuracy 187 | test_data = testset.data 188 | test_label = testset.labels 189 | test_seqlen = testset.seqlen 190 | print("Testing Accuracy:", \ 191 | sess.run(accuracy, feed_dict={x: test_data, y: test_label, 192 | seqlen: test_seqlen})) 193 | -------------------------------------------------------------------------------- /rnn_cell_impl.py: -------------------------------------------------------------------------------- 1 | # Copyright 2015 The TensorFlow Authors. All Rights Reserved. 2 | # 3 | # Licensed under the Apache License, Version 2.0 (the "License"); 4 | # you may not use this file except in compliance with the License. 5 | # You may obtain a copy of the License at 6 | # 7 | # http://www.apache.org/licenses/LICENSE-2.0 8 | # 9 | # Unless required by applicable law or agreed to in writing, software 10 | # distributed under the License is distributed on an "AS IS" BASIS, 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | # See the License for the specific language governing permissions and 13 | # limitations under the License. 14 | # ============================================================================== 15 | """Module implementing RNN Cells. 16 | 17 | This module provides a number of basic commonly used RNN cells, such as LSTM 18 | (Long Short Term Memory) or GRU (Gated Recurrent Unit), and a number of 19 | operators that allow adding dropouts, projections, or embeddings for inputs. 20 | Constructing multi-layer cells is supported by the class `MultiRNNCell`, or by 21 | calling the `rnn` ops several times. 22 | """ 23 | from __future__ import absolute_import 24 | from __future__ import division 25 | from __future__ import print_function 26 | 27 | import collections 28 | import hashlib 29 | import numbers 30 | 31 | from tensorflow.python.eager import context 32 | from tensorflow.python.framework import constant_op 33 | from tensorflow.python.framework import dtypes 34 | from tensorflow.python.framework import ops 35 | from tensorflow.python.framework import tensor_shape 36 | from tensorflow.python.framework import tensor_util 37 | from tensorflow.python.layers import base as base_layer 38 | from tensorflow.python.ops import array_ops 39 | from tensorflow.python.ops import clip_ops 40 | from tensorflow.python.ops import init_ops 41 | from tensorflow.python.ops import math_ops 42 | from tensorflow.python.ops import nn_ops 43 | from tensorflow.python.ops import partitioned_variables 44 | from tensorflow.python.ops import random_ops 45 | from tensorflow.python.ops import tensor_array_ops 46 | from tensorflow.python.ops import variable_scope as vs 47 | from tensorflow.python.ops import variables as tf_variables 48 | from tensorflow.python.platform import tf_logging as logging 49 | from tensorflow.python.util import nest 50 | 51 | 52 | _BIAS_VARIABLE_NAME = "bias" 53 | _WEIGHTS_VARIABLE_NAME = "kernel" 54 | 55 | 56 | def _like_rnncell(cell): 57 | """Checks that a given object is an RNNCell by using duck typing.""" 58 | conditions = [hasattr(cell, "output_size"), hasattr(cell, "state_size"), 59 | hasattr(cell, "zero_state"), callable(cell)] 60 | return all(conditions) 61 | 62 | 63 | def _concat(prefix, suffix, static=False): 64 | """Concat that enables int, Tensor, or TensorShape values. 65 | 66 | This function takes a size specification, which can be an integer, a 67 | TensorShape, or a Tensor, and converts it into a concatenated Tensor 68 | (if static = False) or a list of integers (if static = True). 69 | 70 | Args: 71 | prefix: The prefix; usually the batch size (and/or time step size). 72 | (TensorShape, int, or Tensor.) 73 | suffix: TensorShape, int, or Tensor. 74 | static: If `True`, return a python list with possibly unknown dimensions. 75 | Otherwise return a `Tensor`. 76 | 77 | Returns: 78 | shape: the concatenation of prefix and suffix. 79 | 80 | Raises: 81 | ValueError: if `suffix` is not a scalar or vector (or TensorShape). 82 | ValueError: if prefix or suffix was `None` and asked for dynamic 83 | Tensors out. 84 | """ 85 | if isinstance(prefix, ops.Tensor): 86 | p = prefix 87 | p_static = tensor_util.constant_value(prefix) 88 | if p.shape.ndims == 0: 89 | p = array_ops.expand_dims(p, 0) 90 | elif p.shape.ndims != 1: 91 | raise ValueError("prefix tensor must be either a scalar or vector, " 92 | "but saw tensor: %s" % p) 93 | else: 94 | p = tensor_shape.as_shape(prefix) 95 | p_static = p.as_list() if p.ndims is not None else None 96 | p = (constant_op.constant(p.as_list(), dtype=dtypes.int32) 97 | if p.is_fully_defined() else None) 98 | if isinstance(suffix, ops.Tensor): 99 | s = suffix 100 | s_static = tensor_util.constant_value(suffix) 101 | if s.shape.ndims == 0: 102 | s = array_ops.expand_dims(s, 0) 103 | elif s.shape.ndims != 1: 104 | raise ValueError("suffix tensor must be either a scalar or vector, " 105 | "but saw tensor: %s" % s) 106 | else: 107 | s = tensor_shape.as_shape(suffix) 108 | s_static = s.as_list() if s.ndims is not None else None 109 | s = (constant_op.constant(s.as_list(), dtype=dtypes.int32) 110 | if s.is_fully_defined() else None) 111 | 112 | if static: 113 | shape = tensor_shape.as_shape(p_static).concatenate(s_static) 114 | shape = shape.as_list() if shape.ndims is not None else None 115 | else: 116 | if p is None or s is None: 117 | raise ValueError("Provided a prefix or suffix of None: %s and %s" 118 | % (prefix, suffix)) 119 | shape = array_ops.concat((p, s), 0) 120 | return shape 121 | 122 | 123 | def _zero_state_tensors(state_size, batch_size, dtype): 124 | """Create tensors of zeros based on state_size, batch_size, and dtype.""" 125 | def get_state_shape(s): 126 | """Combine s with batch_size to get a proper tensor shape.""" 127 | c = _concat(batch_size, s) 128 | size = array_ops.zeros(c, dtype=dtype) 129 | if context.in_graph_mode(): 130 | c_static = _concat(batch_size, s, static=True) 131 | size.set_shape(c_static) 132 | return size 133 | return nest.map_structure(get_state_shape, state_size) 134 | 135 | 136 | class RNNCell(base_layer.Layer): 137 | """Abstract object representing an RNN cell. 138 | 139 | Every `RNNCell` must have the properties below and implement `call` with 140 | the signature `(output, next_state) = call(input, state)`. The optional 141 | third input argument, `scope`, is allowed for backwards compatibility 142 | purposes; but should be left off for new subclasses. 143 | 144 | This definition of cell differs from the definition used in the literature. 145 | In the literature, 'cell' refers to an object with a single scalar output. 146 | This definition refers to a horizontal array of such units. 147 | 148 | An RNN cell, in the most abstract setting, is anything that has 149 | a state and performs some operation that takes a matrix of inputs. 150 | This operation results in an output matrix with `self.output_size` columns. 151 | If `self.state_size` is an integer, this operation also results in a new 152 | state matrix with `self.state_size` columns. If `self.state_size` is a 153 | (possibly nested tuple of) TensorShape object(s), then it should return a 154 | matching structure of Tensors having shape `[batch_size].concatenate(s)` 155 | for each `s` in `self.batch_size`. 156 | """ 157 | 158 | def __call__(self, inputs, state, scope=None): 159 | """Run this RNN cell on inputs, starting from the given state. 160 | 161 | Args: 162 | inputs: `2-D` tensor with shape `[batch_size x input_size]`. 163 | state: if `self.state_size` is an integer, this should be a `2-D Tensor` 164 | with shape `[batch_size x self.state_size]`. Otherwise, if 165 | `self.state_size` is a tuple of integers, this should be a tuple 166 | with shapes `[batch_size x s] for s in self.state_size`. 167 | scope: VariableScope for the created subgraph; defaults to class name. 168 | 169 | Returns: 170 | A pair containing: 171 | 172 | - Output: A `2-D` tensor with shape `[batch_size x self.output_size]`. 173 | - New state: Either a single `2-D` tensor, or a tuple of tensors matching 174 | the arity and shapes of `state`. 175 | """ 176 | if scope is not None: 177 | with vs.variable_scope(scope, 178 | custom_getter=self._rnn_get_variable) as scope: 179 | return super(RNNCell, self).__call__(inputs, state, scope=scope) 180 | else: 181 | scope_attrname = "rnncell_scope" 182 | scope = getattr(self, scope_attrname, None) 183 | if scope is None: 184 | scope = vs.variable_scope(vs.get_variable_scope(), 185 | custom_getter=self._rnn_get_variable) 186 | setattr(self, scope_attrname, scope) 187 | with scope: 188 | return super(RNNCell, self).__call__(inputs, state) 189 | 190 | def _rnn_get_variable(self, getter, *args, **kwargs): 191 | variable = getter(*args, **kwargs) 192 | if context.in_graph_mode(): 193 | trainable = (variable in tf_variables.trainable_variables() or 194 | (isinstance(variable, tf_variables.PartitionedVariable) and 195 | list(variable)[0] in tf_variables.trainable_variables())) 196 | else: 197 | trainable = variable._trainable # pylint: disable=protected-access 198 | if trainable and variable not in self._trainable_weights: 199 | self._trainable_weights.append(variable) 200 | elif not trainable and variable not in self._non_trainable_weights: 201 | self._non_trainable_weights.append(variable) 202 | return variable 203 | 204 | @property 205 | def state_size(self): 206 | """size(s) of state(s) used by this cell. 207 | 208 | It can be represented by an Integer, a TensorShape or a tuple of Integers 209 | or TensorShapes. 210 | """ 211 | raise NotImplementedError("Abstract method") 212 | 213 | @property 214 | def output_size(self): 215 | """Integer or TensorShape: size of outputs produced by this cell.""" 216 | raise NotImplementedError("Abstract method") 217 | 218 | def build(self, _): 219 | # This tells the parent Layer object that it's OK to call 220 | # self.add_variable() inside the call() method. 221 | pass 222 | 223 | def zero_state(self, batch_size, dtype): 224 | """Return zero-filled state tensor(s). 225 | 226 | Args: 227 | batch_size: int, float, or unit Tensor representing the batch size. 228 | dtype: the data type to use for the state. 229 | 230 | Returns: 231 | If `state_size` is an int or TensorShape, then the return value is a 232 | `N-D` tensor of shape `[batch_size x state_size]` filled with zeros. 233 | 234 | If `state_size` is a nested list or tuple, then the return value is 235 | a nested list or tuple (of the same structure) of `2-D` tensors with 236 | the shapes `[batch_size x s]` for each s in `state_size`. 237 | """ 238 | # Try to use the last cached zero_state. This is done to avoid recreating 239 | # zeros, especially when eager execution is enabled. 240 | state_size = self.state_size 241 | if hasattr(self, "_last_zero_state"): 242 | (last_state_size, last_batch_size, last_dtype, 243 | last_output) = getattr(self, "_last_zero_state") 244 | if (last_batch_size == batch_size and 245 | last_dtype == dtype and 246 | last_state_size == state_size): 247 | return last_output 248 | with ops.name_scope(type(self).__name__ + "ZeroState", values=[batch_size]): 249 | output = _zero_state_tensors(state_size, batch_size, dtype) 250 | self._last_zero_state = (state_size, batch_size, dtype, output) 251 | return output 252 | 253 | 254 | class BasicRNNCell(RNNCell): 255 | """The most basic RNN cell. 256 | 257 | Args: 258 | num_units: int, The number of units in the RNN cell. 259 | activation: Nonlinearity to use. Default: `tanh`. 260 | reuse: (optional) Python boolean describing whether to reuse variables 261 | in an existing scope. If not `True`, and the existing scope already has 262 | the given variables, an error is raised. 263 | """ 264 | 265 | def __init__(self, num_units, activation=None, reuse=None): 266 | super(BasicRNNCell, self).__init__(_reuse=reuse) 267 | self._num_units = num_units 268 | self._activation = activation or math_ops.tanh 269 | self._linear = None 270 | 271 | @property 272 | def state_size(self): 273 | return self._num_units 274 | 275 | @property 276 | def output_size(self): 277 | return self._num_units 278 | 279 | def call(self, inputs, state): 280 | """Most basic RNN: output = new_state = act(W * input + U * state + B).""" 281 | if self._linear is None: 282 | self._linear = _Linear([inputs, state], self._num_units, True) 283 | 284 | output = self._activation(self._linear([inputs, state])) 285 | return output, output 286 | 287 | 288 | class GRUCell(RNNCell): 289 | """Gated Recurrent Unit cell (cf. http://arxiv.org/abs/1406.1078). 290 | 291 | Args: 292 | num_units: int, The number of units in the GRU cell. 293 | activation: Nonlinearity to use. Default: `tanh`. 294 | reuse: (optional) Python boolean describing whether to reuse variables 295 | in an existing scope. If not `True`, and the existing scope already has 296 | the given variables, an error is raised. 297 | kernel_initializer: (optional) The initializer to use for the weight and 298 | projection matrices. 299 | bias_initializer: (optional) The initializer to use for the bias. 300 | """ 301 | 302 | def __init__(self, 303 | num_units, 304 | activation=None, 305 | reuse=None, 306 | kernel_initializer=None, 307 | bias_initializer=None): 308 | super(GRUCell, self).__init__(_reuse=reuse) 309 | self._num_units = num_units 310 | self._activation = activation or math_ops.tanh 311 | self._kernel_initializer = kernel_initializer 312 | self._bias_initializer = bias_initializer 313 | self._gate_linear = None 314 | self._candidate_linear = None 315 | 316 | @property 317 | def state_size(self): 318 | return self._num_units 319 | 320 | @property 321 | def output_size(self): 322 | return self._num_units 323 | 324 | def call(self, inputs, state): 325 | """Gated recurrent unit (GRU) with nunits cells.""" 326 | if self._gate_linear is None: 327 | bias_ones = self._bias_initializer 328 | if self._bias_initializer is None: 329 | bias_ones = init_ops.constant_initializer(1.0, dtype=inputs.dtype) 330 | with vs.variable_scope("gates"): # Reset gate and update gate. 331 | self._gate_linear = _Linear( 332 | [inputs, state], 333 | 2 * self._num_units, 334 | True, 335 | bias_initializer=bias_ones, 336 | kernel_initializer=self._kernel_initializer) 337 | 338 | value = math_ops.sigmoid(self._gate_linear([inputs, state])) 339 | r, u = array_ops.split(value=value, num_or_size_splits=2, axis=1) 340 | 341 | r_state = r * state 342 | if self._candidate_linear is None: 343 | with vs.variable_scope("candidate"): 344 | self._candidate_linear = _Linear( 345 | [inputs, r_state], 346 | self._num_units, 347 | True, 348 | bias_initializer=self._bias_initializer, 349 | kernel_initializer=self._kernel_initializer) 350 | c = self._activation(self._candidate_linear([inputs, r_state])) 351 | new_h = u * state + (1 - u) * c 352 | return new_h, new_h 353 | 354 | 355 | _LSTMStateTuple = collections.namedtuple("LSTMStateTuple", ("c", "h")) 356 | 357 | 358 | class LSTMStateTuple(_LSTMStateTuple): 359 | """Tuple used by LSTM Cells for `state_size`, `zero_state`, and output state. 360 | 361 | Stores two elements: `(c, h)`, in that order. Where `c` is the hidden state 362 | and `h` is the output. 363 | 364 | Only used when `state_is_tuple=True`. 365 | """ 366 | __slots__ = () 367 | 368 | @property 369 | def dtype(self): 370 | (c, h) = self 371 | if c.dtype != h.dtype: 372 | raise TypeError("Inconsistent internal state: %s vs %s" % 373 | (str(c.dtype), str(h.dtype))) 374 | return c.dtype 375 | 376 | 377 | class BasicLSTMCell(RNNCell): 378 | """Basic LSTM recurrent network cell. 379 | 380 | The implementation is based on: http://arxiv.org/abs/1409.2329. 381 | 382 | We add forget_bias (default: 1) to the biases of the forget gate in order to 383 | reduce the scale of forgetting in the beginning of the training. 384 | 385 | It does not allow cell clipping, a projection layer, and does not 386 | use peep-hole connections: it is the basic baseline. 387 | 388 | For advanced models, please use the full @{tf.nn.rnn_cell.LSTMCell} 389 | that follows. 390 | """ 391 | 392 | def __init__(self, num_units, forget_bias=1.0, 393 | state_is_tuple=True, activation=None, reuse=None): 394 | """Initialize the basic LSTM cell. 395 | 396 | Args: 397 | num_units: int, The number of units in the LSTM cell. 398 | forget_bias: float, The bias added to forget gates (see above). 399 | Must set to `0.0` manually when restoring from CudnnLSTM-trained 400 | checkpoints. 401 | state_is_tuple: If True, accepted and returned states are 2-tuples of 402 | the `c_state` and `m_state`. If False, they are concatenated 403 | along the column axis. The latter behavior will soon be deprecated. 404 | activation: Activation function of the inner states. Default: `tanh`. 405 | reuse: (optional) Python boolean describing whether to reuse variables 406 | in an existing scope. If not `True`, and the existing scope already has 407 | the given variables, an error is raised. 408 | 409 | When restoring from CudnnLSTM-trained checkpoints, must use 410 | CudnnCompatibleLSTMCell instead. 411 | """ 412 | super(BasicLSTMCell, self).__init__(_reuse=reuse) 413 | if not state_is_tuple: 414 | logging.warn("%s: Using a concatenated state is slower and will soon be " 415 | "deprecated. Use state_is_tuple=True.", self) 416 | self._num_units = num_units 417 | self._forget_bias = forget_bias 418 | self._state_is_tuple = state_is_tuple 419 | self._activation = activation or math_ops.tanh 420 | self._linear = None 421 | 422 | @property 423 | def state_size(self): 424 | return (LSTMStateTuple(self._num_units, self._num_units) 425 | if self._state_is_tuple else 2 * self._num_units) 426 | 427 | @property 428 | def output_size(self): 429 | return self._num_units 430 | 431 | def call(self, inputs, state): 432 | """Long short-term memory cell (LSTM). 433 | 434 | Args: 435 | inputs: `2-D` tensor with shape `[batch_size x input_size]`. 436 | state: An `LSTMStateTuple` of state tensors, each shaped 437 | `[batch_size x self.state_size]`, if `state_is_tuple` has been set to 438 | `True`. Otherwise, a `Tensor` shaped 439 | `[batch_size x 2 * self.state_size]`. 440 | 441 | Returns: 442 | A pair containing the new hidden state, and the new state (either a 443 | `LSTMStateTuple` or a concatenated state, depending on 444 | `state_is_tuple`). 445 | """ 446 | sigmoid = math_ops.sigmoid 447 | one = constant_op.constant(1, dtype=dtypes.int32) 448 | # Parameters of gates are concatenated into one multiply for efficiency. 449 | if self._state_is_tuple: 450 | c, h = state 451 | else: 452 | c, h = array_ops.split(value=state, num_or_size_splits=2, axis=one) 453 | 454 | if self._linear is None: 455 | self._linear = _Linear([inputs, h], 4 * self._num_units, True) 456 | # i = input_gate, j = new_input, f = forget_gate, o = output_gate 457 | i, j, f, o = array_ops.split( 458 | value=self._linear([inputs, h]), num_or_size_splits=4, axis=one) 459 | 460 | forget_bias_tensor = constant_op.constant(self._forget_bias, dtype=f.dtype) 461 | # Note that using `add` and `multiply` instead of `+` and `*` gives a 462 | # performance improvement. So using those at the cost of readability. 463 | add = math_ops.add 464 | multiply = math_ops.multiply 465 | new_c = add(multiply(c, sigmoid(add(f, forget_bias_tensor))), 466 | multiply(sigmoid(i), self._activation(j))) 467 | new_h = multiply(self._activation(new_c), sigmoid(o)) 468 | 469 | if self._state_is_tuple: 470 | new_state = LSTMStateTuple(new_c, new_h) 471 | else: 472 | new_state = array_ops.concat([new_c, new_h], 1) 473 | return new_h, new_state 474 | 475 | 476 | class LSTMCell(RNNCell): 477 | """Long short-term memory unit (LSTM) recurrent network cell. 478 | 479 | The default non-peephole implementation is based on: 480 | 481 | http://www.bioinf.jku.at/publications/older/2604.pdf 482 | 483 | S. Hochreiter and J. Schmidhuber. 484 | "Long Short-Term Memory". Neural Computation, 9(8):1735-1780, 1997. 485 | 486 | The peephole implementation is based on: 487 | 488 | https://research.google.com/pubs/archive/43905.pdf 489 | 490 | Hasim Sak, Andrew Senior, and Francoise Beaufays. 491 | "Long short-term memory recurrent neural network architectures for 492 | large scale acoustic modeling." INTERSPEECH, 2014. 493 | 494 | The class uses optional peep-hole connections, optional cell clipping, and 495 | an optional projection layer. 496 | """ 497 | 498 | def __init__(self, num_units, 499 | use_peepholes=False, cell_clip=None, 500 | initializer=None, num_proj=None, proj_clip=None, 501 | num_unit_shards=None, num_proj_shards=None, 502 | forget_bias=1.0, state_is_tuple=True, 503 | activation=None, reuse=None): 504 | """Initialize the parameters for an LSTM cell. 505 | 506 | Args: 507 | num_units: int, The number of units in the LSTM cell. 508 | use_peepholes: bool, set True to enable diagonal/peephole connections. 509 | cell_clip: (optional) A float value, if provided the cell state is clipped 510 | by this value prior to the cell output activation. 511 | initializer: (optional) The initializer to use for the weight and 512 | projection matrices. 513 | num_proj: (optional) int, The output dimensionality for the projection 514 | matrices. If None, no projection is performed. 515 | proj_clip: (optional) A float value. If `num_proj > 0` and `proj_clip` is 516 | provided, then the projected values are clipped elementwise to within 517 | `[-proj_clip, proj_clip]`. 518 | num_unit_shards: Deprecated, will be removed by Jan. 2017. 519 | Use a variable_scope partitioner instead. 520 | num_proj_shards: Deprecated, will be removed by Jan. 2017. 521 | Use a variable_scope partitioner instead. 522 | forget_bias: Biases of the forget gate are initialized by default to 1 523 | in order to reduce the scale of forgetting at the beginning of 524 | the training. Must set it manually to `0.0` when restoring from 525 | CudnnLSTM trained checkpoints. 526 | state_is_tuple: If True, accepted and returned states are 2-tuples of 527 | the `c_state` and `m_state`. If False, they are concatenated 528 | along the column axis. This latter behavior will soon be deprecated. 529 | activation: Activation function of the inner states. Default: `tanh`. 530 | reuse: (optional) Python boolean describing whether to reuse variables 531 | in an existing scope. If not `True`, and the existing scope already has 532 | the given variables, an error is raised. 533 | 534 | When restoring from CudnnLSTM-trained checkpoints, must use 535 | CudnnCompatibleLSTMCell instead. 536 | """ 537 | super(LSTMCell, self).__init__(_reuse=reuse) 538 | if not state_is_tuple: 539 | logging.warn("%s: Using a concatenated state is slower and will soon be " 540 | "deprecated. Use state_is_tuple=True.", self) 541 | if num_unit_shards is not None or num_proj_shards is not None: 542 | logging.warn( 543 | "%s: The num_unit_shards and proj_unit_shards parameters are " 544 | "deprecated and will be removed in Jan 2017. " 545 | "Use a variable scope with a partitioner instead.", self) 546 | 547 | self._num_units = num_units 548 | self._use_peepholes = use_peepholes 549 | self._cell_clip = cell_clip 550 | self._initializer = initializer 551 | self._num_proj = num_proj 552 | self._proj_clip = proj_clip 553 | self._num_unit_shards = num_unit_shards 554 | self._num_proj_shards = num_proj_shards 555 | self._forget_bias = forget_bias 556 | self._state_is_tuple = state_is_tuple 557 | self._activation = activation or math_ops.tanh 558 | 559 | if num_proj: 560 | self._state_size = ( 561 | LSTMStateTuple(num_units, num_proj) 562 | if state_is_tuple else num_units + num_proj) 563 | self._output_size = num_proj 564 | else: 565 | self._state_size = ( 566 | LSTMStateTuple(num_units, num_units) 567 | if state_is_tuple else 2 * num_units) 568 | self._output_size = num_units 569 | self._linear1 = None 570 | self._linear2 = None 571 | if self._use_peepholes: 572 | self._w_f_diag = None 573 | self._w_i_diag = None 574 | self._w_o_diag = None 575 | 576 | @property 577 | def state_size(self): 578 | return self._state_size 579 | 580 | @property 581 | def output_size(self): 582 | return self._output_size 583 | 584 | def call(self, inputs, state): 585 | """Run one step of LSTM. 586 | 587 | Args: 588 | inputs: input Tensor, 2D, batch x num_units. 589 | state: if `state_is_tuple` is False, this must be a state Tensor, 590 | `2-D, batch x state_size`. If `state_is_tuple` is True, this must be a 591 | tuple of state Tensors, both `2-D`, with column sizes `c_state` and 592 | `m_state`. 593 | 594 | Returns: 595 | A tuple containing: 596 | 597 | - A `2-D, [batch x output_dim]`, Tensor representing the output of the 598 | LSTM after reading `inputs` when previous state was `state`. 599 | Here output_dim is: 600 | num_proj if num_proj was set, 601 | num_units otherwise. 602 | - Tensor(s) representing the new state of LSTM after reading `inputs` when 603 | the previous state was `state`. Same type and shape(s) as `state`. 604 | 605 | Raises: 606 | ValueError: If input size cannot be inferred from inputs via 607 | static shape inference. 608 | """ 609 | num_proj = self._num_units if self._num_proj is None else self._num_proj 610 | sigmoid = math_ops.sigmoid 611 | 612 | if self._state_is_tuple: 613 | (c_prev, m_prev) = state 614 | else: 615 | c_prev = array_ops.slice(state, [0, 0], [-1, self._num_units]) 616 | m_prev = array_ops.slice(state, [0, self._num_units], [-1, num_proj]) 617 | 618 | dtype = inputs.dtype 619 | input_size = inputs.get_shape().with_rank(2)[1] 620 | if input_size.value is None: 621 | raise ValueError("Could not infer input size from inputs.get_shape()[-1]") 622 | if self._linear1 is None: 623 | scope = vs.get_variable_scope() 624 | with vs.variable_scope( 625 | scope, initializer=self._initializer) as unit_scope: 626 | if self._num_unit_shards is not None: 627 | unit_scope.set_partitioner( 628 | partitioned_variables.fixed_size_partitioner( 629 | self._num_unit_shards)) 630 | self._linear1 = _Linear([inputs, m_prev], 4 * self._num_units, True) 631 | 632 | # i = input_gate, j = new_input, f = forget_gate, o = output_gate 633 | lstm_matrix = self._linear1([inputs, m_prev]) 634 | i, j, f, o = array_ops.split( 635 | value=lstm_matrix, num_or_size_splits=4, axis=1) 636 | # Diagonal connections 637 | if self._use_peepholes and not self._w_f_diag: 638 | scope = vs.get_variable_scope() 639 | with vs.variable_scope( 640 | scope, initializer=self._initializer) as unit_scope: 641 | with vs.variable_scope(unit_scope): 642 | self._w_f_diag = vs.get_variable( 643 | "w_f_diag", shape=[self._num_units], dtype=dtype) 644 | self._w_i_diag = vs.get_variable( 645 | "w_i_diag", shape=[self._num_units], dtype=dtype) 646 | self._w_o_diag = vs.get_variable( 647 | "w_o_diag", shape=[self._num_units], dtype=dtype) 648 | 649 | if self._use_peepholes: 650 | c = (sigmoid(f + self._forget_bias + self._w_f_diag * c_prev) * c_prev + 651 | sigmoid(i + self._w_i_diag * c_prev) * self._activation(j)) 652 | else: 653 | c = (sigmoid(f + self._forget_bias) * c_prev + sigmoid(i) * 654 | self._activation(j)) 655 | 656 | if self._cell_clip is not None: 657 | # pylint: disable=invalid-unary-operand-type 658 | c = clip_ops.clip_by_value(c, -self._cell_clip, self._cell_clip) 659 | # pylint: enable=invalid-unary-operand-type 660 | if self._use_peepholes: 661 | m = sigmoid(o + self._w_o_diag * c) * self._activation(c) 662 | else: 663 | m = sigmoid(o) * self._activation(c) 664 | 665 | if self._num_proj is not None: 666 | if self._linear2 is None: 667 | scope = vs.get_variable_scope() 668 | with vs.variable_scope(scope, initializer=self._initializer): 669 | with vs.variable_scope("projection") as proj_scope: 670 | if self._num_proj_shards is not None: 671 | proj_scope.set_partitioner( 672 | partitioned_variables.fixed_size_partitioner( 673 | self._num_proj_shards)) 674 | self._linear2 = _Linear(m, self._num_proj, False) 675 | m = self._linear2(m) 676 | 677 | if self._proj_clip is not None: 678 | # pylint: disable=invalid-unary-operand-type 679 | m = clip_ops.clip_by_value(m, -self._proj_clip, self._proj_clip) 680 | # pylint: enable=invalid-unary-operand-type 681 | 682 | new_state = (LSTMStateTuple(c, m) if self._state_is_tuple else 683 | array_ops.concat([c, m], 1)) 684 | return m, new_state 685 | 686 | 687 | def _enumerated_map_structure_up_to(shallow_structure, map_fn, *args, **kwargs): 688 | ix = [0] 689 | def enumerated_fn(*inner_args, **inner_kwargs): 690 | r = map_fn(ix[0], *inner_args, **inner_kwargs) 691 | ix[0] += 1 692 | return r 693 | return nest.map_structure_up_to(shallow_structure, 694 | enumerated_fn, *args, **kwargs) 695 | 696 | 697 | def _default_dropout_state_filter_visitor(substate): 698 | if isinstance(substate, LSTMStateTuple): 699 | # Do not perform dropout on the memory state. 700 | return LSTMStateTuple(c=False, h=True) 701 | elif isinstance(substate, tensor_array_ops.TensorArray): 702 | return False 703 | return True 704 | 705 | 706 | class DropoutWrapper(RNNCell): 707 | """Operator adding dropout to inputs and outputs of the given cell.""" 708 | 709 | def __init__(self, cell, input_keep_prob=1.0, output_keep_prob=1.0, 710 | state_keep_prob=1.0, variational_recurrent=False, 711 | input_size=None, dtype=None, seed=None, 712 | dropout_state_filter_visitor=None): 713 | """Create a cell with added input, state, and/or output dropout. 714 | 715 | If `variational_recurrent` is set to `True` (**NOT** the default behavior), 716 | then the same dropout mask is applied at every step, as described in: 717 | 718 | Y. Gal, Z Ghahramani. "A Theoretically Grounded Application of Dropout in 719 | Recurrent Neural Networks". https://arxiv.org/abs/1512.05287 720 | 721 | Otherwise a different dropout mask is applied at every time step. 722 | 723 | Note, by default (unless a custom `dropout_state_filter` is provided), 724 | the memory state (`c` component of any `LSTMStateTuple`) passing through 725 | a `DropoutWrapper` is never modified. This behavior is described in the 726 | above article. 727 | 728 | Args: 729 | cell: an RNNCell, a projection to output_size is added to it. 730 | input_keep_prob: unit Tensor or float between 0 and 1, input keep 731 | probability; if it is constant and 1, no input dropout will be added. 732 | output_keep_prob: unit Tensor or float between 0 and 1, output keep 733 | probability; if it is constant and 1, no output dropout will be added. 734 | state_keep_prob: unit Tensor or float between 0 and 1, output keep 735 | probability; if it is constant and 1, no output dropout will be added. 736 | State dropout is performed on the outgoing states of the cell. 737 | **Note** the state components to which dropout is applied when 738 | `state_keep_prob` is in `(0, 1)` are also determined by 739 | the argument `dropout_state_filter_visitor` (e.g. by default dropout 740 | is never applied to the `c` component of an `LSTMStateTuple`). 741 | variational_recurrent: Python bool. If `True`, then the same 742 | dropout pattern is applied across all time steps per run call. 743 | If this parameter is set, `input_size` **must** be provided. 744 | input_size: (optional) (possibly nested tuple of) `TensorShape` objects 745 | containing the depth(s) of the input tensors expected to be passed in to 746 | the `DropoutWrapper`. Required and used **iff** 747 | `variational_recurrent = True` and `input_keep_prob < 1`. 748 | dtype: (optional) The `dtype` of the input, state, and output tensors. 749 | Required and used **iff** `variational_recurrent = True`. 750 | seed: (optional) integer, the randomness seed. 751 | dropout_state_filter_visitor: (optional), default: (see below). Function 752 | that takes any hierarchical level of the state and returns 753 | a scalar or depth=1 structure of Python booleans describing 754 | which terms in the state should be dropped out. In addition, if the 755 | function returns `True`, dropout is applied across this sublevel. If 756 | the function returns `False`, dropout is not applied across this entire 757 | sublevel. 758 | Default behavior: perform dropout on all terms except the memory (`c`) 759 | state of `LSTMCellState` objects, and don't try to apply dropout to 760 | `TensorArray` objects: 761 | ``` 762 | def dropout_state_filter_visitor(s): 763 | if isinstance(s, LSTMCellState): 764 | # Never perform dropout on the c state. 765 | return LSTMCellState(c=False, h=True) 766 | elif isinstance(s, TensorArray): 767 | return False 768 | return True 769 | ``` 770 | 771 | Raises: 772 | TypeError: if `cell` is not an `RNNCell`, or `keep_state_fn` is provided 773 | but not `callable`. 774 | ValueError: if any of the keep_probs are not between 0 and 1. 775 | """ 776 | if not _like_rnncell(cell): 777 | raise TypeError("The parameter cell is not a RNNCell.") 778 | if (dropout_state_filter_visitor is not None 779 | and not callable(dropout_state_filter_visitor)): 780 | raise TypeError("dropout_state_filter_visitor must be callable") 781 | self._dropout_state_filter = ( 782 | dropout_state_filter_visitor or _default_dropout_state_filter_visitor) 783 | with ops.name_scope("DropoutWrapperInit"): 784 | def tensor_and_const_value(v): 785 | tensor_value = ops.convert_to_tensor(v) 786 | const_value = tensor_util.constant_value(tensor_value) 787 | return (tensor_value, const_value) 788 | for prob, attr in [(input_keep_prob, "input_keep_prob"), 789 | (state_keep_prob, "state_keep_prob"), 790 | (output_keep_prob, "output_keep_prob")]: 791 | tensor_prob, const_prob = tensor_and_const_value(prob) 792 | if const_prob is not None: 793 | if const_prob < 0 or const_prob > 1: 794 | raise ValueError("Parameter %s must be between 0 and 1: %d" 795 | % (attr, const_prob)) 796 | setattr(self, "_%s" % attr, float(const_prob)) 797 | else: 798 | setattr(self, "_%s" % attr, tensor_prob) 799 | 800 | # Set cell, variational_recurrent, seed before running the code below 801 | self._cell = cell 802 | self._variational_recurrent = variational_recurrent 803 | self._seed = seed 804 | 805 | self._recurrent_input_noise = None 806 | self._recurrent_state_noise = None 807 | self._recurrent_output_noise = None 808 | 809 | if variational_recurrent: 810 | if dtype is None: 811 | raise ValueError( 812 | "When variational_recurrent=True, dtype must be provided") 813 | 814 | def convert_to_batch_shape(s): 815 | # Prepend a 1 for the batch dimension; for recurrent 816 | # variational dropout we use the same dropout mask for all 817 | # batch elements. 818 | return array_ops.concat( 819 | ([1], tensor_shape.TensorShape(s).as_list()), 0) 820 | 821 | def batch_noise(s, inner_seed): 822 | shape = convert_to_batch_shape(s) 823 | return random_ops.random_uniform(shape, seed=inner_seed, dtype=dtype) 824 | 825 | if (not isinstance(self._input_keep_prob, numbers.Real) or 826 | self._input_keep_prob < 1.0): 827 | if input_size is None: 828 | raise ValueError( 829 | "When variational_recurrent=True and input_keep_prob < 1.0 or " 830 | "is unknown, input_size must be provided") 831 | self._recurrent_input_noise = _enumerated_map_structure_up_to( 832 | input_size, 833 | lambda i, s: batch_noise(s, inner_seed=self._gen_seed("input", i)), 834 | input_size) 835 | self._recurrent_state_noise = _enumerated_map_structure_up_to( 836 | cell.state_size, 837 | lambda i, s: batch_noise(s, inner_seed=self._gen_seed("state", i)), 838 | cell.state_size) 839 | self._recurrent_output_noise = _enumerated_map_structure_up_to( 840 | cell.output_size, 841 | lambda i, s: batch_noise(s, inner_seed=self._gen_seed("output", i)), 842 | cell.output_size) 843 | 844 | def _gen_seed(self, salt_prefix, index): 845 | if self._seed is None: 846 | return None 847 | salt = "%s_%d" % (salt_prefix, index) 848 | string = (str(self._seed) + salt).encode("utf-8") 849 | return int(hashlib.md5(string).hexdigest()[:8], 16) & 0x7FFFFFFF 850 | 851 | @property 852 | def state_size(self): 853 | return self._cell.state_size 854 | 855 | @property 856 | def output_size(self): 857 | return self._cell.output_size 858 | 859 | def zero_state(self, batch_size, dtype): 860 | with ops.name_scope(type(self).__name__ + "ZeroState", values=[batch_size]): 861 | return self._cell.zero_state(batch_size, dtype) 862 | 863 | def _variational_recurrent_dropout_value( 864 | self, index, value, noise, keep_prob): 865 | """Performs dropout given the pre-calculated noise tensor.""" 866 | # uniform [keep_prob, 1.0 + keep_prob) 867 | random_tensor = keep_prob + noise 868 | 869 | # 0. if [keep_prob, 1.0) and 1. if [1.0, 1.0 + keep_prob) 870 | binary_tensor = math_ops.floor(random_tensor) 871 | ret = math_ops.div(value, keep_prob) * binary_tensor 872 | ret.set_shape(value.get_shape()) 873 | return ret 874 | 875 | def _dropout(self, values, salt_prefix, recurrent_noise, keep_prob, 876 | shallow_filtered_substructure=None): 877 | """Decides whether to perform standard dropout or recurrent dropout.""" 878 | 879 | if shallow_filtered_substructure is None: 880 | # Put something so we traverse the entire structure; inside the 881 | # dropout function we check to see if leafs of this are bool or not. 882 | shallow_filtered_substructure = values 883 | 884 | if not self._variational_recurrent: 885 | def dropout(i, do_dropout, v): 886 | if not isinstance(do_dropout, bool) or do_dropout: 887 | return nn_ops.dropout( 888 | v, keep_prob=keep_prob, seed=self._gen_seed(salt_prefix, i)) 889 | else: 890 | return v 891 | return _enumerated_map_structure_up_to( 892 | shallow_filtered_substructure, dropout, 893 | *[shallow_filtered_substructure, values]) 894 | else: 895 | def dropout(i, do_dropout, v, n): 896 | if not isinstance(do_dropout, bool) or do_dropout: 897 | return self._variational_recurrent_dropout_value(i, v, n, keep_prob) 898 | else: 899 | return v 900 | return _enumerated_map_structure_up_to( 901 | shallow_filtered_substructure, dropout, 902 | *[shallow_filtered_substructure, values, recurrent_noise]) 903 | 904 | def __call__(self, inputs, state, scope=None): 905 | """Run the cell with the declared dropouts.""" 906 | def _should_dropout(p): 907 | return (not isinstance(p, float)) or p < 1 908 | 909 | if _should_dropout(self._input_keep_prob): 910 | inputs = self._dropout(inputs, "input", 911 | self._recurrent_input_noise, 912 | self._input_keep_prob) 913 | output, new_state = self._cell(inputs, state, scope) 914 | if _should_dropout(self._state_keep_prob): 915 | # Identify which subsets of the state to perform dropout on and 916 | # which ones to keep. 917 | shallow_filtered_substructure = nest.get_traverse_shallow_structure( 918 | self._dropout_state_filter, new_state) 919 | new_state = self._dropout(new_state, "state", 920 | self._recurrent_state_noise, 921 | self._state_keep_prob, 922 | shallow_filtered_substructure) 923 | if _should_dropout(self._output_keep_prob): 924 | output = self._dropout(output, "output", 925 | self._recurrent_output_noise, 926 | self._output_keep_prob) 927 | return output, new_state 928 | 929 | 930 | class ResidualWrapper(RNNCell): 931 | """RNNCell wrapper that ensures cell inputs are added to the outputs.""" 932 | 933 | def __init__(self, cell, residual_fn=None): 934 | """Constructs a `ResidualWrapper` for `cell`. 935 | 936 | Args: 937 | cell: An instance of `RNNCell`. 938 | residual_fn: (Optional) The function to map raw cell inputs and raw cell 939 | outputs to the actual cell outputs of the residual network. 940 | Defaults to calling nest.map_structure on (lambda i, o: i + o), inputs 941 | and outputs. 942 | """ 943 | self._cell = cell 944 | self._residual_fn = residual_fn 945 | 946 | @property 947 | def state_size(self): 948 | return self._cell.state_size 949 | 950 | @property 951 | def output_size(self): 952 | return self._cell.output_size 953 | 954 | def zero_state(self, batch_size, dtype): 955 | with ops.name_scope(type(self).__name__ + "ZeroState", values=[batch_size]): 956 | return self._cell.zero_state(batch_size, dtype) 957 | 958 | def __call__(self, inputs, state, scope=None): 959 | """Run the cell and then apply the residual_fn on its inputs to its outputs. 960 | 961 | Args: 962 | inputs: cell inputs. 963 | state: cell state. 964 | scope: optional cell scope. 965 | 966 | Returns: 967 | Tuple of cell outputs and new state. 968 | 969 | Raises: 970 | TypeError: If cell inputs and outputs have different structure (type). 971 | ValueError: If cell inputs and outputs have different structure (value). 972 | """ 973 | outputs, new_state = self._cell(inputs, state, scope=scope) 974 | # Ensure shapes match 975 | def assert_shape_match(inp, out): 976 | inp.get_shape().assert_is_compatible_with(out.get_shape()) 977 | def default_residual_fn(inputs, outputs): 978 | nest.assert_same_structure(inputs, outputs) 979 | nest.map_structure(assert_shape_match, inputs, outputs) 980 | return nest.map_structure(lambda inp, out: inp + out, inputs, outputs) 981 | res_outputs = (self._residual_fn or default_residual_fn)(inputs, outputs) 982 | return (res_outputs, new_state) 983 | 984 | 985 | class DeviceWrapper(RNNCell): 986 | """Operator that ensures an RNNCell runs on a particular device.""" 987 | 988 | def __init__(self, cell, device): 989 | """Construct a `DeviceWrapper` for `cell` with device `device`. 990 | 991 | Ensures the wrapped `cell` is called with `tf.device(device)`. 992 | 993 | Args: 994 | cell: An instance of `RNNCell`. 995 | device: A device string or function, for passing to `tf.device`. 996 | """ 997 | self._cell = cell 998 | self._device = device 999 | 1000 | @property 1001 | def state_size(self): 1002 | return self._cell.state_size 1003 | 1004 | @property 1005 | def output_size(self): 1006 | return self._cell.output_size 1007 | 1008 | def zero_state(self, batch_size, dtype): 1009 | with ops.name_scope(type(self).__name__ + "ZeroState", values=[batch_size]): 1010 | with ops.device(self._device): 1011 | return self._cell.zero_state(batch_size, dtype) 1012 | 1013 | def __call__(self, inputs, state, scope=None): 1014 | """Run the cell on specified device.""" 1015 | with ops.device(self._device): 1016 | return self._cell(inputs, state, scope=scope) 1017 | 1018 | 1019 | class MultiRNNCell(RNNCell): 1020 | """RNN cell composed sequentially of multiple simple cells.""" 1021 | 1022 | def __init__(self, cells, state_is_tuple=True): 1023 | """Create a RNN cell composed sequentially of a number of RNNCells. 1024 | 1025 | Args: 1026 | cells: list of RNNCells that will be composed in this order. 1027 | state_is_tuple: If True, accepted and returned states are n-tuples, where 1028 | `n = len(cells)`. If False, the states are all 1029 | concatenated along the column axis. This latter behavior will soon be 1030 | deprecated. 1031 | 1032 | Raises: 1033 | ValueError: if cells is empty (not allowed), or at least one of the cells 1034 | returns a state tuple but the flag `state_is_tuple` is `False`. 1035 | """ 1036 | super(MultiRNNCell, self).__init__() 1037 | if not cells: 1038 | raise ValueError("Must specify at least one cell for MultiRNNCell.") 1039 | if not nest.is_sequence(cells): 1040 | raise TypeError( 1041 | "cells must be a list or tuple, but saw: %s." % cells) 1042 | 1043 | self._cells = cells 1044 | self._state_is_tuple = state_is_tuple 1045 | if not state_is_tuple: 1046 | if any(nest.is_sequence(c.state_size) for c in self._cells): 1047 | raise ValueError("Some cells return tuples of states, but the flag " 1048 | "state_is_tuple is not set. State sizes are: %s" 1049 | % str([c.state_size for c in self._cells])) 1050 | 1051 | @property 1052 | def state_size(self): 1053 | if self._state_is_tuple: 1054 | return tuple(cell.state_size for cell in self._cells) 1055 | else: 1056 | return sum([cell.state_size for cell in self._cells]) 1057 | 1058 | @property 1059 | def output_size(self): 1060 | return self._cells[-1].output_size 1061 | 1062 | def zero_state(self, batch_size, dtype): 1063 | with ops.name_scope(type(self).__name__ + "ZeroState", values=[batch_size]): 1064 | if self._state_is_tuple: 1065 | return tuple(cell.zero_state(batch_size, dtype) for cell in self._cells) 1066 | else: 1067 | # We know here that state_size of each cell is not a tuple and 1068 | # presumably does not contain TensorArrays or anything else fancy 1069 | return super(MultiRNNCell, self).zero_state(batch_size, dtype) 1070 | 1071 | def call(self, inputs, state): 1072 | """Run this multi-layer cell on inputs, starting from state.""" 1073 | cur_state_pos = 0 1074 | cur_inp = inputs 1075 | new_states = [] 1076 | for i, cell in enumerate(self._cells): 1077 | with vs.variable_scope("cell_%d" % i): 1078 | if self._state_is_tuple: 1079 | if not nest.is_sequence(state): 1080 | raise ValueError( 1081 | "Expected state to be a tuple of length %d, but received: %s" % 1082 | (len(self.state_size), state)) 1083 | cur_state = state[i] 1084 | else: 1085 | cur_state = array_ops.slice(state, [0, cur_state_pos], 1086 | [-1, cell.state_size]) 1087 | cur_state_pos += cell.state_size 1088 | cur_inp, new_state = cell(cur_inp, cur_state) 1089 | new_states.append(new_state) 1090 | 1091 | new_states = (tuple(new_states) if self._state_is_tuple else 1092 | array_ops.concat(new_states, 1)) 1093 | 1094 | return cur_inp, new_states 1095 | 1096 | 1097 | class _SlimRNNCell(RNNCell): 1098 | """A simple wrapper for slim.rnn_cells.""" 1099 | 1100 | def __init__(self, cell_fn): 1101 | """Create a SlimRNNCell from a cell_fn. 1102 | 1103 | Args: 1104 | cell_fn: a function which takes (inputs, state, scope) and produces the 1105 | outputs and the new_state. Additionally when called with inputs=None and 1106 | state=None it should return (initial_outputs, initial_state). 1107 | 1108 | Raises: 1109 | TypeError: if cell_fn is not callable 1110 | ValueError: if cell_fn cannot produce a valid initial state. 1111 | """ 1112 | if not callable(cell_fn): 1113 | raise TypeError("cell_fn %s needs to be callable", cell_fn) 1114 | self._cell_fn = cell_fn 1115 | self._cell_name = cell_fn.func.__name__ 1116 | init_output, init_state = self._cell_fn(None, None) 1117 | output_shape = init_output.get_shape() 1118 | state_shape = init_state.get_shape() 1119 | self._output_size = output_shape.with_rank(2)[1].value 1120 | self._state_size = state_shape.with_rank(2)[1].value 1121 | if self._output_size is None: 1122 | raise ValueError("Initial output created by %s has invalid shape %s" % 1123 | (self._cell_name, output_shape)) 1124 | if self._state_size is None: 1125 | raise ValueError("Initial state created by %s has invalid shape %s" % 1126 | (self._cell_name, state_shape)) 1127 | 1128 | @property 1129 | def state_size(self): 1130 | return self._state_size 1131 | 1132 | @property 1133 | def output_size(self): 1134 | return self._output_size 1135 | 1136 | def __call__(self, inputs, state, scope=None): 1137 | scope = scope or self._cell_name 1138 | output, state = self._cell_fn(inputs, state, scope=scope) 1139 | return output, state 1140 | 1141 | 1142 | class _Linear(object): 1143 | """Linear map: sum_i(args[i] * W[i]), where W[i] is a variable. 1144 | 1145 | Args: 1146 | args: a 2D Tensor or a list of 2D, batch x n, Tensors. 1147 | output_size: int, second dimension of weight variable. 1148 | dtype: data type for variables. 1149 | build_bias: boolean, whether to build a bias variable. 1150 | bias_initializer: starting value to initialize the bias 1151 | (default is all zeros). 1152 | kernel_initializer: starting value to initialize the weight. 1153 | 1154 | Raises: 1155 | ValueError: if inputs_shape is wrong. 1156 | """ 1157 | 1158 | def __init__(self, 1159 | args, 1160 | output_size, 1161 | build_bias, 1162 | bias_initializer=None, 1163 | kernel_initializer=None): 1164 | self._build_bias = build_bias 1165 | 1166 | if args is None or (nest.is_sequence(args) and not args): 1167 | raise ValueError("`args` must be specified") 1168 | if not nest.is_sequence(args): 1169 | args = [args] 1170 | self._is_sequence = False 1171 | else: 1172 | self._is_sequence = True 1173 | 1174 | # Calculate the total size of arguments on dimension 1. 1175 | total_arg_size = 0 1176 | shapes = [a.get_shape() for a in args] 1177 | for shape in shapes: 1178 | if shape.ndims != 2: 1179 | raise ValueError("linear is expecting 2D arguments: %s" % shapes) 1180 | if shape[1].value is None: 1181 | raise ValueError("linear expects shape[1] to be provided for shape %s, " 1182 | "but saw %s" % (shape, shape[1])) 1183 | else: 1184 | total_arg_size += shape[1].value 1185 | 1186 | dtype = [a.dtype for a in args][0] 1187 | 1188 | scope = vs.get_variable_scope() 1189 | with vs.variable_scope(scope) as outer_scope: 1190 | self._weights = vs.get_variable( 1191 | _WEIGHTS_VARIABLE_NAME, [total_arg_size, output_size], 1192 | dtype=dtype, 1193 | initializer=kernel_initializer) 1194 | if build_bias: 1195 | with vs.variable_scope(outer_scope) as inner_scope: 1196 | inner_scope.set_partitioner(None) 1197 | if bias_initializer is None: 1198 | bias_initializer = init_ops.constant_initializer(0.0, dtype=dtype) 1199 | self._biases = vs.get_variable( 1200 | _BIAS_VARIABLE_NAME, [output_size], 1201 | dtype=dtype, 1202 | initializer=bias_initializer) 1203 | 1204 | def __call__(self, args): 1205 | if not self._is_sequence: 1206 | args = [args] 1207 | 1208 | if len(args) == 1: 1209 | res = math_ops.matmul(args[0], self._weights) 1210 | else: 1211 | # Explicitly creating a one for a minor performance improvement. 1212 | one = constant_op.constant(1, dtype=dtypes.int32) 1213 | res = math_ops.matmul(array_ops.concat(args, one), self._weights) 1214 | if self._build_bias: 1215 | res = nn_ops.bias_add(res, self._biases) 1216 | return res 1217 | 1218 | 1219 | # TODO(xpan): Remove this function in a follow up. 1220 | def _linear(args, 1221 | output_size, 1222 | bias, 1223 | bias_initializer=None, 1224 | kernel_initializer=None): 1225 | """Linear map: sum_i(args[i] * W[i]), where W[i] is a variable. 1226 | 1227 | Args: 1228 | args: a 2D Tensor or a list of 2D, batch x n, Tensors. 1229 | output_size: int, second dimension of W[i]. 1230 | bias: boolean, whether to add a bias term or not. 1231 | bias_initializer: starting value to initialize the bias 1232 | (default is all zeros). 1233 | kernel_initializer: starting value to initialize the weight. 1234 | 1235 | Returns: 1236 | A 2D Tensor with shape [batch x output_size] equal to 1237 | sum_i(args[i] * W[i]), where W[i]s are newly created matrices. 1238 | 1239 | Raises: 1240 | ValueError: if some of the arguments has unspecified or wrong shape. 1241 | """ 1242 | if args is None or (nest.is_sequence(args) and not args): 1243 | raise ValueError("`args` must be specified") 1244 | if not nest.is_sequence(args): 1245 | args = [args] 1246 | 1247 | # Calculate the total size of arguments on dimension 1. 1248 | total_arg_size = 0 1249 | shapes = [a.get_shape() for a in args] 1250 | for shape in shapes: 1251 | if shape.ndims != 2: 1252 | raise ValueError("linear is expecting 2D arguments: %s" % shapes) 1253 | if shape[1].value is None: 1254 | raise ValueError("linear expects shape[1] to be provided for shape %s, " 1255 | "but saw %s" % (shape, shape[1])) 1256 | else: 1257 | total_arg_size += shape[1].value 1258 | 1259 | dtype = [a.dtype for a in args][0] 1260 | 1261 | # Now the computation. 1262 | scope = vs.get_variable_scope() 1263 | with vs.variable_scope(scope) as outer_scope: 1264 | weights = vs.get_variable( 1265 | _WEIGHTS_VARIABLE_NAME, [total_arg_size, output_size], 1266 | dtype=dtype, 1267 | initializer=kernel_initializer) 1268 | if len(args) == 1: 1269 | res = math_ops.matmul(args[0], weights) 1270 | else: 1271 | res = math_ops.matmul(array_ops.concat(args, 1), weights) 1272 | if not bias: 1273 | return res 1274 | with vs.variable_scope(outer_scope) as inner_scope: 1275 | inner_scope.set_partitioner(None) 1276 | if bias_initializer is None: 1277 | bias_initializer = init_ops.constant_initializer(0.0, dtype=dtype) 1278 | biases = vs.get_variable( 1279 | _BIAS_VARIABLE_NAME, [output_size], 1280 | dtype=dtype, 1281 | initializer=bias_initializer) 1282 | return nn_ops.bias_add(res, biases) 1283 | -------------------------------------------------------------------------------- /file_list: -------------------------------------------------------------------------------- 1 | Z_RADR_I_Z9002_20161018004900_O_DOR_SA_CAP.bin 2 | Z_RADR_I_Z9002_20161018005500_O_DOR_SA_CAP.bin 3 | Z_RADR_I_Z9002_20161018010100_O_DOR_SA_CAP.bin 4 | Z_RADR_I_Z9002_20161018010600_O_DOR_SA_CAP.bin 5 | Z_RADR_I_Z9002_20161018011200_O_DOR_SA_CAP.bin 6 | Z_RADR_I_Z9002_20161018011800_O_DOR_SA_CAP.bin 7 | Z_RADR_I_Z9002_20161018012400_O_DOR_SA_CAP.bin 8 | Z_RADR_I_Z9002_20161018012900_O_DOR_SA_CAP.bin 9 | Z_RADR_I_Z9002_20161018013500_O_DOR_SA_CAP.bin 10 | Z_RADR_I_Z9002_20161018014100_O_DOR_SA_CAP.bin 11 | Z_RADR_I_Z9002_20161018014600_O_DOR_SA_CAP.bin 12 | Z_RADR_I_Z9002_20161018015200_O_DOR_SA_CAP.bin 13 | Z_RADR_I_Z9002_20161018015800_O_DOR_SA_CAP.bin 14 | Z_RADR_I_Z9002_20161018020400_O_DOR_SA_CAP.bin 15 | Z_RADR_I_Z9002_20161018020900_O_DOR_SA_CAP.bin 16 | Z_RADR_I_Z9002_20161018021500_O_DOR_SA_CAP.bin 17 | Z_RADR_I_Z9002_20161018022100_O_DOR_SA_CAP.bin 18 | Z_RADR_I_Z9002_20161018022600_O_DOR_SA_CAP.bin 19 | Z_RADR_I_Z9002_20161018023200_O_DOR_SA_CAP.bin 20 | Z_RADR_I_Z9002_20161018023800_O_DOR_SA_CAP.bin 21 | Z_RADR_I_Z9002_20161018024400_O_DOR_SA_CAP.bin 22 | Z_RADR_I_Z9002_20161018024900_O_DOR_SA_CAP.bin 23 | Z_RADR_I_Z9002_20161018025500_O_DOR_SA_CAP.bin 24 | Z_RADR_I_Z9002_20161018030100_O_DOR_SA_CAP.bin 25 | Z_RADR_I_Z9002_20161018030600_O_DOR_SA_CAP.bin 26 | Z_RADR_I_Z9002_20161018031200_O_DOR_SA_CAP.bin 27 | Z_RADR_I_Z9002_20161018031800_O_DOR_SA_CAP.bin 28 | Z_RADR_I_Z9002_20161018032300_O_DOR_SA_CAP.bin 29 | Z_RADR_I_Z9002_20161018032900_O_DOR_SA_CAP.bin 30 | Z_RADR_I_Z9002_20161018033500_O_DOR_SA_CAP.bin 31 | Z_RADR_I_Z9002_20161018034100_O_DOR_SA_CAP.bin 32 | Z_RADR_I_Z9002_20161018034600_O_DOR_SA_CAP.bin 33 | Z_RADR_I_Z9002_20161018035200_O_DOR_SA_CAP.bin 34 | Z_RADR_I_Z9002_20161018035800_O_DOR_SA_CAP.bin 35 | Z_RADR_I_Z9002_20161018040300_O_DOR_SA_CAP.bin 36 | Z_RADR_I_Z9002_20161018040900_O_DOR_SA_CAP.bin 37 | Z_RADR_I_Z9002_20161018041500_O_DOR_SA_CAP.bin 38 | Z_RADR_I_Z9002_20161018042100_O_DOR_SA_CAP.bin 39 | Z_RADR_I_Z9002_20161018042600_O_DOR_SA_CAP.bin 40 | Z_RADR_I_Z9002_20161018043200_O_DOR_SA_CAP.bin 41 | Z_RADR_I_Z9002_20161018043800_O_DOR_SA_CAP.bin 42 | Z_RADR_I_Z9002_20161018044300_O_DOR_SA_CAP.bin 43 | Z_RADR_I_Z9002_20161018044900_O_DOR_SA_CAP.bin 44 | Z_RADR_I_Z9002_20161018045500_O_DOR_SA_CAP.bin 45 | Z_RADR_I_Z9002_20161018050000_O_DOR_SA_CAP.bin 46 | Z_RADR_I_Z9002_20161018050600_O_DOR_SA_CAP.bin 47 | Z_RADR_I_Z9002_20161018051200_O_DOR_SA_CAP.bin 48 | Z_RADR_I_Z9002_20161018051800_O_DOR_SA_CAP.bin 49 | Z_RADR_I_Z9002_20161018052300_O_DOR_SA_CAP.bin 50 | Z_RADR_I_Z9002_20161018052900_O_DOR_SA_CAP.bin 51 | Z_RADR_I_Z9002_20161018053500_O_DOR_SA_CAP.bin 52 | Z_RADR_I_Z9002_20161018054000_O_DOR_SA_CAP.bin 53 | Z_RADR_I_Z9002_20161018054600_O_DOR_SA_CAP.bin 54 | Z_RADR_I_Z9002_20161018055200_O_DOR_SA_CAP.bin 55 | Z_RADR_I_Z9002_20161018055800_O_DOR_SA_CAP.bin 56 | Z_RADR_I_Z9002_20161018060300_O_DOR_SA_CAP.bin 57 | Z_RADR_I_Z9002_20161018060900_O_DOR_SA_CAP.bin 58 | Z_RADR_I_Z9002_20161018061500_O_DOR_SA_CAP.bin 59 | Z_RADR_I_Z9002_20161018062000_O_DOR_SA_CAP.bin 60 | Z_RADR_I_Z9002_20161018062600_O_DOR_SA_CAP.bin 61 | Z_RADR_I_Z9002_20161018063200_O_DOR_SA_CAP.bin 62 | Z_RADR_I_Z9002_20161018063800_O_DOR_SA_CAP.bin 63 | Z_RADR_I_Z9002_20161018064300_O_DOR_SA_CAP.bin 64 | Z_RADR_I_Z9002_20161018064900_O_DOR_SA_CAP.bin 65 | Z_RADR_I_Z9002_20161018065500_O_DOR_SA_CAP.bin 66 | Z_RADR_I_Z9002_20161018070000_O_DOR_SA_CAP.bin 67 | Z_RADR_I_Z9002_20161018070600_O_DOR_SA_CAP.bin 68 | Z_RADR_I_Z9002_20161018071200_O_DOR_SA_CAP.bin 69 | Z_RADR_I_Z9002_20161018071700_O_DOR_SA_CAP.bin 70 | Z_RADR_I_Z9002_20161018072300_O_DOR_SA_CAP.bin 71 | Z_RADR_I_Z9002_20161018072900_O_DOR_SA_CAP.bin 72 | Z_RADR_I_Z9002_20161018073500_O_DOR_SA_CAP.bin 73 | Z_RADR_I_Z9002_20161018074000_O_DOR_SA_CAP.bin 74 | Z_RADR_I_Z9002_20161018074600_O_DOR_SA_CAP.bin 75 | Z_RADR_I_Z9002_20161018075200_O_DOR_SA_CAP.bin 76 | Z_RADR_I_Z9002_20161018075700_O_DOR_SA_CAP.bin 77 | Z_RADR_I_Z9002_20161018080300_O_DOR_SA_CAP.bin 78 | Z_RADR_I_Z9002_20161018080900_O_DOR_SA_CAP.bin 79 | Z_RADR_I_Z9002_20161018081500_O_DOR_SA_CAP.bin 80 | Z_RADR_I_Z9002_20161018082100_O_DOR_SA_CAP.bin 81 | Z_RADR_I_Z9002_20161018082600_O_DOR_SA_CAP.bin 82 | Z_RADR_I_Z9002_20161018083200_O_DOR_SA_CAP.bin 83 | Z_RADR_I_Z9002_20161018083800_O_DOR_SA_CAP.bin 84 | Z_RADR_I_Z9002_20161018084400_O_DOR_SA_CAP.bin 85 | Z_RADR_I_Z9002_20161018084900_O_DOR_SA_CAP.bin 86 | Z_RADR_I_Z9002_20161018085500_O_DOR_SA_CAP.bin 87 | Z_RADR_I_Z9002_20161018090100_O_DOR_SA_CAP.bin 88 | Z_RADR_I_Z9002_20161018090600_O_DOR_SA_CAP.bin 89 | Z_RADR_I_Z9002_20161018091200_O_DOR_SA_CAP.bin 90 | Z_RADR_I_Z9002_20161018091800_O_DOR_SA_CAP.bin 91 | Z_RADR_I_Z9002_20161018092400_O_DOR_SA_CAP.bin 92 | Z_RADR_I_Z9002_20161018092900_O_DOR_SA_CAP.bin 93 | Z_RADR_I_Z9002_20161018093500_O_DOR_SA_CAP.bin 94 | Z_RADR_I_Z9002_20161018094100_O_DOR_SA_CAP.bin 95 | Z_RADR_I_Z9002_20161018094600_O_DOR_SA_CAP.bin 96 | Z_RADR_I_Z9002_20161018095200_O_DOR_SA_CAP.bin 97 | Z_RADR_I_Z9002_20161018095800_O_DOR_SA_CAP.bin 98 | Z_RADR_I_Z9002_20161018100300_O_DOR_SA_CAP.bin 99 | Z_RADR_I_Z9002_20161018100900_O_DOR_SA_CAP.bin 100 | Z_RADR_I_Z9002_20161018101500_O_DOR_SA_CAP.bin 101 | Z_RADR_I_Z9002_20161018102100_O_DOR_SA_CAP.bin 102 | Z_RADR_I_Z9002_20161018102600_O_DOR_SA_CAP.bin 103 | Z_RADR_I_Z9002_20161018103200_O_DOR_SA_CAP.bin 104 | Z_RADR_I_Z9002_20161018103800_O_DOR_SA_CAP.bin 105 | Z_RADR_I_Z9002_20161018104300_O_DOR_SA_CAP.bin 106 | Z_RADR_I_Z9002_20161018104900_O_DOR_SA_CAP.bin 107 | Z_RADR_I_Z9002_20161018105500_O_DOR_SA_CAP.bin 108 | Z_RADR_I_Z9002_20161018110100_O_DOR_SA_CAP.bin 109 | Z_RADR_I_Z9002_20161018110600_O_DOR_SA_CAP.bin 110 | Z_RADR_I_Z9002_20161018111200_O_DOR_SA_CAP.bin 111 | Z_RADR_I_Z9002_20161018111800_O_DOR_SA_CAP.bin 112 | Z_RADR_I_Z9002_20161018112300_O_DOR_SA_CAP.bin 113 | Z_RADR_I_Z9002_20161018112900_O_DOR_SA_CAP.bin 114 | Z_RADR_I_Z9002_20161018113500_O_DOR_SA_CAP.bin 115 | Z_RADR_I_Z9002_20161018114100_O_DOR_SA_CAP.bin 116 | Z_RADR_I_Z9002_20161018114600_O_DOR_SA_CAP.bin 117 | Z_RADR_I_Z9002_20161018115200_O_DOR_SA_CAP.bin 118 | Z_RADR_I_Z9002_20161018115800_O_DOR_SA_CAP.bin 119 | Z_RADR_I_Z9002_20161018120300_O_DOR_SA_CAP.bin 120 | Z_RADR_I_Z9002_20161018120900_O_DOR_SA_CAP.bin 121 | Z_RADR_I_Z9002_20161018121500_O_DOR_SA_CAP.bin 122 | Z_RADR_I_Z9002_20161018122100_O_DOR_SA_CAP.bin 123 | Z_RADR_I_Z9002_20161018122600_O_DOR_SA_CAP.bin 124 | Z_RADR_I_Z9002_20161018123200_O_DOR_SA_CAP.bin 125 | Z_RADR_I_Z9002_20161018123800_O_DOR_SA_CAP.bin 126 | Z_RADR_I_Z9002_20161018124300_O_DOR_SA_CAP.bin 127 | Z_RADR_I_Z9002_20161018124900_O_DOR_SA_CAP.bin 128 | Z_RADR_I_Z9002_20161018125500_O_DOR_SA_CAP.bin 129 | Z_RADR_I_Z9002_20161018130000_O_DOR_SA_CAP.bin 130 | Z_RADR_I_Z9002_20161018130600_O_DOR_SA_CAP.bin 131 | Z_RADR_I_Z9002_20161018131200_O_DOR_SA_CAP.bin 132 | Z_RADR_I_Z9002_20161018131800_O_DOR_SA_CAP.bin 133 | Z_RADR_I_Z9002_20161018132300_O_DOR_SA_CAP.bin 134 | Z_RADR_I_Z9002_20161018132900_O_DOR_SA_CAP.bin 135 | Z_RADR_I_Z9002_20161018133500_O_DOR_SA_CAP.bin 136 | Z_RADR_I_Z9002_20161018134000_O_DOR_SA_CAP.bin 137 | Z_RADR_I_Z9002_20161018134600_O_DOR_SA_CAP.bin 138 | Z_RADR_I_Z9002_20161018135200_O_DOR_SA_CAP.bin 139 | Z_RADR_I_Z9002_20161018135800_O_DOR_SA_CAP.bin 140 | Z_RADR_I_Z9002_20161018140300_O_DOR_SA_CAP.bin 141 | Z_RADR_I_Z9002_20161018140900_O_DOR_SA_CAP.bin 142 | Z_RADR_I_Z9002_20161018141500_O_DOR_SA_CAP.bin 143 | Z_RADR_I_Z9002_20161018142000_O_DOR_SA_CAP.bin 144 | Z_RADR_I_Z9002_20161018142600_O_DOR_SA_CAP.bin 145 | Z_RADR_I_Z9002_20161018143200_O_DOR_SA_CAP.bin 146 | Z_RADR_I_Z9002_20161018143800_O_DOR_SA_CAP.bin 147 | Z_RADR_I_Z9002_20161018144300_O_DOR_SA_CAP.bin 148 | Z_RADR_I_Z9002_20161018144900_O_DOR_SA_CAP.bin 149 | Z_RADR_I_Z9002_20161018145500_O_DOR_SA_CAP.bin 150 | Z_RADR_I_Z9002_20161018150000_O_DOR_SA_CAP.bin 151 | Z_RADR_I_Z9002_20161018150600_O_DOR_SA_CAP.bin 152 | Z_RADR_I_Z9002_20161018151200_O_DOR_SA_CAP.bin 153 | Z_RADR_I_Z9002_20161018151800_O_DOR_SA_CAP.bin 154 | Z_RADR_I_Z9002_20161018152300_O_DOR_SA_CAP.bin 155 | Z_RADR_I_Z9002_20161018152900_O_DOR_SA_CAP.bin 156 | Z_RADR_I_Z9002_20161018153500_O_DOR_SA_CAP.bin 157 | Z_RADR_I_Z9002_20161018154000_O_DOR_SA_CAP.bin 158 | Z_RADR_I_Z9002_20161018154600_O_DOR_SA_CAP.bin 159 | Z_RADR_I_Z9002_20161018155200_O_DOR_SA_CAP.bin 160 | Z_RADR_I_Z9002_20161018155700_O_DOR_SA_CAP.bin 161 | Z_RADR_I_Z9002_20161018160300_O_DOR_SA_CAP.bin 162 | Z_RADR_I_Z9002_20161018160900_O_DOR_SA_CAP.bin 163 | Z_RADR_I_Z9002_20161018161500_O_DOR_SA_CAP.bin 164 | Z_RADR_I_Z9002_20161018162100_O_DOR_SA_CAP.bin 165 | Z_RADR_I_Z9002_20161018162700_O_DOR_SA_CAP.bin 166 | Z_RADR_I_Z9002_20161018163200_O_DOR_SA_CAP.bin 167 | Z_RADR_I_Z9002_20161018163800_O_DOR_SA_CAP.bin 168 | Z_RADR_I_Z9002_20161018164400_O_DOR_SA_CAP.bin 169 | Z_RADR_I_Z9002_20161018164900_O_DOR_SA_CAP.bin 170 | Z_RADR_I_Z9002_20161018165500_O_DOR_SA_CAP.bin 171 | Z_RADR_I_Z9002_20161018170100_O_DOR_SA_CAP.bin 172 | Z_RADR_I_Z9002_20161018170700_O_DOR_SA_CAP.bin 173 | Z_RADR_I_Z9002_20161018171200_O_DOR_SA_CAP.bin 174 | Z_RADR_I_Z9002_20161018171800_O_DOR_SA_CAP.bin 175 | Z_RADR_I_Z9002_20161018172400_O_DOR_SA_CAP.bin 176 | Z_RADR_I_Z9002_20161018172900_O_DOR_SA_CAP.bin 177 | Z_RADR_I_Z9002_20161018173500_O_DOR_SA_CAP.bin 178 | Z_RADR_I_Z9002_20161018174100_O_DOR_SA_CAP.bin 179 | Z_RADR_I_Z9002_20161018174700_O_DOR_SA_CAP.bin 180 | Z_RADR_I_Z9002_20161018175200_O_DOR_SA_CAP.bin 181 | Z_RADR_I_Z9002_20161018175800_O_DOR_SA_CAP.bin 182 | Z_RADR_I_Z9002_20161018180400_O_DOR_SA_CAP.bin 183 | Z_RADR_I_Z9002_20161018180900_O_DOR_SA_CAP.bin 184 | Z_RADR_I_Z9002_20161018181500_O_DOR_SA_CAP.bin 185 | Z_RADR_I_Z9002_20161018182100_O_DOR_SA_CAP.bin 186 | Z_RADR_I_Z9002_20161018182600_O_DOR_SA_CAP.bin 187 | Z_RADR_I_Z9002_20161018183200_O_DOR_SA_CAP.bin 188 | Z_RADR_I_Z9002_20161018183800_O_DOR_SA_CAP.bin 189 | Z_RADR_I_Z9002_20161018184400_O_DOR_SA_CAP.bin 190 | Z_RADR_I_Z9002_20161018184900_O_DOR_SA_CAP.bin 191 | Z_RADR_I_Z9002_20161018185500_O_DOR_SA_CAP.bin 192 | Z_RADR_I_Z9002_20161018190100_O_DOR_SA_CAP.bin 193 | Z_RADR_I_Z9002_20161018190600_O_DOR_SA_CAP.bin 194 | Z_RADR_I_Z9002_20161018191200_O_DOR_SA_CAP.bin 195 | Z_RADR_I_Z9002_20161018191800_O_DOR_SA_CAP.bin 196 | Z_RADR_I_Z9002_20161018192400_O_DOR_SA_CAP.bin 197 | Z_RADR_I_Z9002_20161018192900_O_DOR_SA_CAP.bin 198 | Z_RADR_I_Z9002_20161018193500_O_DOR_SA_CAP.bin 199 | Z_RADR_I_Z9002_20161018194100_O_DOR_SA_CAP.bin 200 | Z_RADR_I_Z9002_20161018194600_O_DOR_SA_CAP.bin 201 | Z_RADR_I_Z9002_20161018195200_O_DOR_SA_CAP.bin 202 | Z_RADR_I_Z9002_20161018195800_O_DOR_SA_CAP.bin 203 | Z_RADR_I_Z9002_20161018200400_O_DOR_SA_CAP.bin 204 | Z_RADR_I_Z9002_20161018200900_O_DOR_SA_CAP.bin 205 | Z_RADR_I_Z9002_20161018201500_O_DOR_SA_CAP.bin 206 | Z_RADR_I_Z9002_20161018202100_O_DOR_SA_CAP.bin 207 | Z_RADR_I_Z9002_20161018202600_O_DOR_SA_CAP.bin 208 | Z_RADR_I_Z9002_20161018203200_O_DOR_SA_CAP.bin 209 | Z_RADR_I_Z9002_20161018203800_O_DOR_SA_CAP.bin 210 | Z_RADR_I_Z9002_20161018204300_O_DOR_SA_CAP.bin 211 | Z_RADR_I_Z9002_20161018204900_O_DOR_SA_CAP.bin 212 | Z_RADR_I_Z9002_20161018205500_O_DOR_SA_CAP.bin 213 | Z_RADR_I_Z9002_20161018210100_O_DOR_SA_CAP.bin 214 | Z_RADR_I_Z9002_20161018210600_O_DOR_SA_CAP.bin 215 | Z_RADR_I_Z9002_20161018211200_O_DOR_SA_CAP.bin 216 | Z_RADR_I_Z9002_20161018211800_O_DOR_SA_CAP.bin 217 | Z_RADR_I_Z9002_20161018212300_O_DOR_SA_CAP.bin 218 | Z_RADR_I_Z9002_20161018212900_O_DOR_SA_CAP.bin 219 | Z_RADR_I_Z9002_20161018213500_O_DOR_SA_CAP.bin 220 | Z_RADR_I_Z9002_20161018214000_O_DOR_SA_CAP.bin 221 | Z_RADR_I_Z9002_20161018214600_O_DOR_SA_CAP.bin 222 | Z_RADR_I_Z9002_20161018215200_O_DOR_SA_CAP.bin 223 | Z_RADR_I_Z9002_20161018215800_O_DOR_SA_CAP.bin 224 | Z_RADR_I_Z9002_20161018220300_O_DOR_SA_CAP.bin 225 | Z_RADR_I_Z9002_20161018220900_O_DOR_SA_CAP.bin 226 | Z_RADR_I_Z9002_20161018221500_O_DOR_SA_CAP.bin 227 | Z_RADR_I_Z9002_20161018222000_O_DOR_SA_CAP.bin 228 | Z_RADR_I_Z9002_20161018222600_O_DOR_SA_CAP.bin 229 | Z_RADR_I_Z9002_20161018223200_O_DOR_SA_CAP.bin 230 | Z_RADR_I_Z9002_20161018223800_O_DOR_SA_CAP.bin 231 | Z_RADR_I_Z9002_20161018224300_O_DOR_SA_CAP.bin 232 | Z_RADR_I_Z9002_20161018224900_O_DOR_SA_CAP.bin 233 | Z_RADR_I_Z9002_20161018225500_O_DOR_SA_CAP.bin 234 | Z_RADR_I_Z9002_20161018230000_O_DOR_SA_CAP.bin 235 | Z_RADR_I_Z9002_20161018230600_O_DOR_SA_CAP.bin 236 | Z_RADR_I_Z9002_20161018231200_O_DOR_SA_CAP.bin 237 | Z_RADR_I_Z9002_20161018231800_O_DOR_SA_CAP.bin 238 | Z_RADR_I_Z9002_20161018232300_O_DOR_SA_CAP.bin 239 | Z_RADR_I_Z9002_20161018232900_O_DOR_SA_CAP.bin 240 | Z_RADR_I_Z9002_20161018233500_O_DOR_SA_CAP.bin 241 | Z_RADR_I_Z9002_20161018234000_O_DOR_SA_CAP.bin 242 | Z_RADR_I_Z9002_20161018234600_O_DOR_SA_CAP.bin 243 | Z_RADR_I_Z9002_20161018235200_O_DOR_SA_CAP.bin 244 | Z_RADR_I_Z9002_20161018235800_O_DOR_SA_CAP.bin 245 | Z_RADR_I_Z9002_20161019000400_O_DOR_SA_CAP.bin 246 | Z_RADR_I_Z9002_20161019000900_O_DOR_SA_CAP.bin 247 | Z_RADR_I_Z9002_20161019001500_O_DOR_SA_CAP.bin 248 | Z_RADR_I_Z9002_20161019002100_O_DOR_SA_CAP.bin 249 | Z_RADR_I_Z9002_20161019002700_O_DOR_SA_CAP.bin 250 | Z_RADR_I_Z9002_20161019003200_O_DOR_SA_CAP.bin 251 | Z_RADR_I_Z9002_20161019003800_O_DOR_SA_CAP.bin 252 | Z_RADR_I_Z9002_20161019004400_O_DOR_SA_CAP.bin 253 | Z_RADR_I_Z9002_20161019004900_O_DOR_SA_CAP.bin 254 | Z_RADR_I_Z9002_20161019005500_O_DOR_SA_CAP.bin 255 | Z_RADR_I_Z9002_20161019010100_O_DOR_SA_CAP.bin 256 | Z_RADR_I_Z9002_20161019010700_O_DOR_SA_CAP.bin 257 | Z_RADR_I_Z9002_20161019011200_O_DOR_SA_CAP.bin 258 | Z_RADR_I_Z9002_20161019011800_O_DOR_SA_CAP.bin 259 | Z_RADR_I_Z9002_20161019012400_O_DOR_SA_CAP.bin 260 | Z_RADR_I_Z9002_20161019012900_O_DOR_SA_CAP.bin 261 | Z_RADR_I_Z9002_20161019013500_O_DOR_SA_CAP.bin 262 | Z_RADR_I_Z9002_20161019014100_O_DOR_SA_CAP.bin 263 | Z_RADR_I_Z9002_20161019014700_O_DOR_SA_CAP.bin 264 | Z_RADR_I_Z9002_20161019015200_O_DOR_SA_CAP.bin 265 | Z_RADR_I_Z9002_20161019015800_O_DOR_SA_CAP.bin 266 | Z_RADR_I_Z9002_20161019020400_O_DOR_SA_CAP.bin 267 | Z_RADR_I_Z9002_20161019020900_O_DOR_SA_CAP.bin 268 | Z_RADR_I_Z9002_20161019021500_O_DOR_SA_CAP.bin 269 | Z_RADR_I_Z9002_20161019022100_O_DOR_SA_CAP.bin 270 | Z_RADR_I_Z9002_20161019022700_O_DOR_SA_CAP.bin 271 | Z_RADR_I_Z9002_20161019023200_O_DOR_SA_CAP.bin 272 | Z_RADR_I_Z9002_20161019023800_O_DOR_SA_CAP.bin 273 | Z_RADR_I_Z9002_20161019024400_O_DOR_SA_CAP.bin 274 | Z_RADR_I_Z9002_20161019024900_O_DOR_SA_CAP.bin 275 | Z_RADR_I_Z9002_20161019025500_O_DOR_SA_CAP.bin 276 | Z_RADR_I_Z9002_20161019030100_O_DOR_SA_CAP.bin 277 | Z_RADR_I_Z9002_20161019030700_O_DOR_SA_CAP.bin 278 | Z_RADR_I_Z9002_20161019031200_O_DOR_SA_CAP.bin 279 | Z_RADR_I_Z9002_20161019031800_O_DOR_SA_CAP.bin 280 | Z_RADR_I_Z9002_20161019032400_O_DOR_SA_CAP.bin 281 | Z_RADR_I_Z9002_20161019032900_O_DOR_SA_CAP.bin 282 | Z_RADR_I_Z9002_20161019033500_O_DOR_SA_CAP.bin 283 | Z_RADR_I_Z9002_20161019034100_O_DOR_SA_CAP.bin 284 | Z_RADR_I_Z9002_20161019034600_O_DOR_SA_CAP.bin 285 | Z_RADR_I_Z9002_20161019035200_O_DOR_SA_CAP.bin 286 | Z_RADR_I_Z9002_20161019035800_O_DOR_SA_CAP.bin 287 | Z_RADR_I_Z9002_20161019040400_O_DOR_SA_CAP.bin 288 | Z_RADR_I_Z9002_20161019040900_O_DOR_SA_CAP.bin 289 | Z_RADR_I_Z9002_20161019041500_O_DOR_SA_CAP.bin 290 | Z_RADR_I_Z9002_20161019042100_O_DOR_SA_CAP.bin 291 | Z_RADR_I_Z9002_20161019042600_O_DOR_SA_CAP.bin 292 | Z_RADR_I_Z9002_20161019043200_O_DOR_SA_CAP.bin 293 | Z_RADR_I_Z9002_20161019043800_O_DOR_SA_CAP.bin 294 | Z_RADR_I_Z9002_20161019044400_O_DOR_SA_CAP.bin 295 | Z_RADR_I_Z9002_20161019044900_O_DOR_SA_CAP.bin 296 | Z_RADR_I_Z9002_20161019045500_O_DOR_SA_CAP.bin 297 | Z_RADR_I_Z9002_20161019050100_O_DOR_SA_CAP.bin 298 | Z_RADR_I_Z9002_20161019050600_O_DOR_SA_CAP.bin 299 | Z_RADR_I_Z9002_20161019051200_O_DOR_SA_CAP.bin 300 | Z_RADR_I_Z9002_20161019051800_O_DOR_SA_CAP.bin 301 | Z_RADR_I_Z9002_20161019052400_O_DOR_SA_CAP.bin 302 | Z_RADR_I_Z9002_20161019052900_O_DOR_SA_CAP.bin 303 | Z_RADR_I_Z9002_20161019053500_O_DOR_SA_CAP.bin 304 | Z_RADR_I_Z9002_20161019054100_O_DOR_SA_CAP.bin 305 | Z_RADR_I_Z9002_20161019054600_O_DOR_SA_CAP.bin 306 | Z_RADR_I_Z9002_20161019055200_O_DOR_SA_CAP.bin 307 | Z_RADR_I_Z9002_20161019055800_O_DOR_SA_CAP.bin 308 | Z_RADR_I_Z9002_20161019060300_O_DOR_SA_CAP.bin 309 | Z_RADR_I_Z9002_20161019060900_O_DOR_SA_CAP.bin 310 | Z_RADR_I_Z9002_20161019061500_O_DOR_SA_CAP.bin 311 | Z_RADR_I_Z9002_20161019062100_O_DOR_SA_CAP.bin 312 | Z_RADR_I_Z9002_20161019062600_O_DOR_SA_CAP.bin 313 | Z_RADR_I_Z9002_20161019063200_O_DOR_SA_CAP.bin 314 | Z_RADR_I_Z9002_20161019063800_O_DOR_SA_CAP.bin 315 | Z_RADR_I_Z9002_20161019064300_O_DOR_SA_CAP.bin 316 | Z_RADR_I_Z9002_20161019064900_O_DOR_SA_CAP.bin 317 | Z_RADR_I_Z9002_20161019065500_O_DOR_SA_CAP.bin 318 | Z_RADR_I_Z9002_20161019070100_O_DOR_SA_CAP.bin 319 | Z_RADR_I_Z9002_20161019070600_O_DOR_SA_CAP.bin 320 | Z_RADR_I_Z9002_20161019071200_O_DOR_SA_CAP.bin 321 | Z_RADR_I_Z9002_20161019071800_O_DOR_SA_CAP.bin 322 | Z_RADR_I_Z9002_20161019072300_O_DOR_SA_CAP.bin 323 | Z_RADR_I_Z9002_20161019072900_O_DOR_SA_CAP.bin 324 | Z_RADR_I_Z9002_20161019073500_O_DOR_SA_CAP.bin 325 | Z_RADR_I_Z9002_20161019074100_O_DOR_SA_CAP.bin 326 | Z_RADR_I_Z9002_20161019074600_O_DOR_SA_CAP.bin 327 | Z_RADR_I_Z9002_20161019075200_O_DOR_SA_CAP.bin 328 | Z_RADR_I_Z9002_20161019075800_O_DOR_SA_CAP.bin 329 | Z_RADR_I_Z9002_20161019080300_O_DOR_SA_CAP.bin 330 | Z_RADR_I_Z9002_20161019081000_O_DOR_SA_CAP.bin 331 | Z_RADR_I_Z9002_20161019081500_O_DOR_SA_CAP.bin 332 | Z_RADR_I_Z9002_20161019082100_O_DOR_SA_CAP.bin 333 | Z_RADR_I_Z9002_20161019082700_O_DOR_SA_CAP.bin 334 | Z_RADR_I_Z9002_20161019083300_O_DOR_SA_CAP.bin 335 | Z_RADR_I_Z9002_20161019083800_O_DOR_SA_CAP.bin 336 | Z_RADR_I_Z9002_20161019084400_O_DOR_SA_CAP.bin 337 | Z_RADR_I_Z9002_20161019085000_O_DOR_SA_CAP.bin 338 | Z_RADR_I_Z9002_20161019085500_O_DOR_SA_CAP.bin 339 | Z_RADR_I_Z9002_20161019090100_O_DOR_SA_CAP.bin 340 | Z_RADR_I_Z9002_20161019090700_O_DOR_SA_CAP.bin 341 | Z_RADR_I_Z9002_20161019091300_O_DOR_SA_CAP.bin 342 | Z_RADR_I_Z9002_20161019091800_O_DOR_SA_CAP.bin 343 | Z_RADR_I_Z9002_20161019092400_O_DOR_SA_CAP.bin 344 | Z_RADR_I_Z9002_20161019093000_O_DOR_SA_CAP.bin 345 | Z_RADR_I_Z9002_20161019093500_O_DOR_SA_CAP.bin 346 | Z_RADR_I_Z9002_20161019094100_O_DOR_SA_CAP.bin 347 | Z_RADR_I_Z9002_20161019094700_O_DOR_SA_CAP.bin 348 | Z_RADR_I_Z9002_20161019095200_O_DOR_SA_CAP.bin 349 | Z_RADR_I_Z9002_20161019095800_O_DOR_SA_CAP.bin 350 | Z_RADR_I_Z9002_20161019100400_O_DOR_SA_CAP.bin 351 | Z_RADR_I_Z9002_20161019101000_O_DOR_SA_CAP.bin 352 | Z_RADR_I_Z9002_20161019101500_O_DOR_SA_CAP.bin 353 | Z_RADR_I_Z9002_20161019102100_O_DOR_SA_CAP.bin 354 | Z_RADR_I_Z9002_20161019102700_O_DOR_SA_CAP.bin 355 | Z_RADR_I_Z9002_20161019103200_O_DOR_SA_CAP.bin 356 | Z_RADR_I_Z9002_20161019103800_O_DOR_SA_CAP.bin 357 | Z_RADR_I_Z9002_20161019104400_O_DOR_SA_CAP.bin 358 | Z_RADR_I_Z9002_20161019105000_O_DOR_SA_CAP.bin 359 | Z_RADR_I_Z9002_20161019105500_O_DOR_SA_CAP.bin 360 | Z_RADR_I_Z9002_20161019110100_O_DOR_SA_CAP.bin 361 | Z_RADR_I_Z9002_20161019110700_O_DOR_SA_CAP.bin 362 | Z_RADR_I_Z9002_20161019111200_O_DOR_SA_CAP.bin 363 | Z_RADR_I_Z9002_20161019111800_O_DOR_SA_CAP.bin 364 | Z_RADR_I_Z9002_20161019112400_O_DOR_SA_CAP.bin 365 | Z_RADR_I_Z9002_20161019113000_O_DOR_SA_CAP.bin 366 | Z_RADR_I_Z9002_20161019113500_O_DOR_SA_CAP.bin 367 | Z_RADR_I_Z9002_20161019114100_O_DOR_SA_CAP.bin 368 | Z_RADR_I_Z9002_20161019114700_O_DOR_SA_CAP.bin 369 | Z_RADR_I_Z9002_20161019115200_O_DOR_SA_CAP.bin 370 | Z_RADR_I_Z9002_20161019115800_O_DOR_SA_CAP.bin 371 | Z_RADR_I_Z9002_20161019120400_O_DOR_SA_CAP.bin 372 | Z_RADR_I_Z9002_20161019120900_O_DOR_SA_CAP.bin 373 | Z_RADR_I_Z9002_20161019121500_O_DOR_SA_CAP.bin 374 | Z_RADR_I_Z9002_20161019122100_O_DOR_SA_CAP.bin 375 | Z_RADR_I_Z9002_20161019122700_O_DOR_SA_CAP.bin 376 | Z_RADR_I_Z9002_20161019123200_O_DOR_SA_CAP.bin 377 | Z_RADR_I_Z9002_20161019123800_O_DOR_SA_CAP.bin 378 | Z_RADR_I_Z9002_20161019124400_O_DOR_SA_CAP.bin 379 | Z_RADR_I_Z9002_20161019124900_O_DOR_SA_CAP.bin 380 | Z_RADR_I_Z9002_20161019125500_O_DOR_SA_CAP.bin 381 | Z_RADR_I_Z9002_20161019130100_O_DOR_SA_CAP.bin 382 | Z_RADR_I_Z9002_20161019130700_O_DOR_SA_CAP.bin 383 | Z_RADR_I_Z9002_20161019131200_O_DOR_SA_CAP.bin 384 | Z_RADR_I_Z9002_20161019131800_O_DOR_SA_CAP.bin 385 | Z_RADR_I_Z9002_20161019132400_O_DOR_SA_CAP.bin 386 | Z_RADR_I_Z9002_20161019132900_O_DOR_SA_CAP.bin 387 | Z_RADR_I_Z9002_20161019133500_O_DOR_SA_CAP.bin 388 | Z_RADR_I_Z9002_20161019134100_O_DOR_SA_CAP.bin 389 | Z_RADR_I_Z9002_20161019134700_O_DOR_SA_CAP.bin 390 | Z_RADR_I_Z9002_20161019135200_O_DOR_SA_CAP.bin 391 | Z_RADR_I_Z9002_20161019135800_O_DOR_SA_CAP.bin 392 | Z_RADR_I_Z9002_20161019140400_O_DOR_SA_CAP.bin 393 | Z_RADR_I_Z9002_20161019140900_O_DOR_SA_CAP.bin 394 | Z_RADR_I_Z9002_20161019141500_O_DOR_SA_CAP.bin 395 | Z_RADR_I_Z9002_20161019142100_O_DOR_SA_CAP.bin 396 | Z_RADR_I_Z9002_20161019142700_O_DOR_SA_CAP.bin 397 | Z_RADR_I_Z9002_20161019143200_O_DOR_SA_CAP.bin 398 | Z_RADR_I_Z9002_20161019143800_O_DOR_SA_CAP.bin 399 | Z_RADR_I_Z9002_20161019144400_O_DOR_SA_CAP.bin 400 | Z_RADR_I_Z9002_20161019144900_O_DOR_SA_CAP.bin 401 | Z_RADR_I_Z9002_20161019145500_O_DOR_SA_CAP.bin 402 | Z_RADR_I_Z9002_20161019150100_O_DOR_SA_CAP.bin 403 | Z_RADR_I_Z9002_20161019150700_O_DOR_SA_CAP.bin 404 | Z_RADR_I_Z9002_20161019151200_O_DOR_SA_CAP.bin 405 | Z_RADR_I_Z9002_20161019151800_O_DOR_SA_CAP.bin 406 | Z_RADR_I_Z9002_20161019152400_O_DOR_SA_CAP.bin 407 | Z_RADR_I_Z9002_20161019152900_O_DOR_SA_CAP.bin 408 | Z_RADR_I_Z9002_20161019153500_O_DOR_SA_CAP.bin 409 | Z_RADR_I_Z9002_20161019154100_O_DOR_SA_CAP.bin 410 | Z_RADR_I_Z9002_20161019154700_O_DOR_SA_CAP.bin 411 | Z_RADR_I_Z9002_20161019155200_O_DOR_SA_CAP.bin 412 | Z_RADR_I_Z9002_20161019155800_O_DOR_SA_CAP.bin 413 | Z_RADR_I_Z9002_20161019160400_O_DOR_SA_CAP.bin 414 | Z_RADR_I_Z9002_20161019160900_O_DOR_SA_CAP.bin 415 | Z_RADR_I_Z9002_20161019161600_O_DOR_SA_CAP.bin 416 | Z_RADR_I_Z9002_20161019162100_O_DOR_SA_CAP.bin 417 | Z_RADR_I_Z9002_20161019162700_O_DOR_SA_CAP.bin 418 | Z_RADR_I_Z9002_20161019163300_O_DOR_SA_CAP.bin 419 | Z_RADR_I_Z9002_20161019163900_O_DOR_SA_CAP.bin 420 | Z_RADR_I_Z9002_20161019164400_O_DOR_SA_CAP.bin 421 | Z_RADR_I_Z9002_20161019165000_O_DOR_SA_CAP.bin 422 | Z_RADR_I_Z9002_20161019165600_O_DOR_SA_CAP.bin 423 | Z_RADR_I_Z9002_20161019170100_O_DOR_SA_CAP.bin 424 | Z_RADR_I_Z9002_20161019170700_O_DOR_SA_CAP.bin 425 | Z_RADR_I_Z9002_20161019171300_O_DOR_SA_CAP.bin 426 | Z_RADR_I_Z9002_20161019171800_O_DOR_SA_CAP.bin 427 | Z_RADR_I_Z9002_20161019172400_O_DOR_SA_CAP.bin 428 | Z_RADR_I_Z9002_20161019173000_O_DOR_SA_CAP.bin 429 | Z_RADR_I_Z9002_20161019173600_O_DOR_SA_CAP.bin 430 | Z_RADR_I_Z9002_20161019174100_O_DOR_SA_CAP.bin 431 | Z_RADR_I_Z9002_20161019174700_O_DOR_SA_CAP.bin 432 | Z_RADR_I_Z9002_20161019175300_O_DOR_SA_CAP.bin 433 | Z_RADR_I_Z9002_20161019175800_O_DOR_SA_CAP.bin 434 | Z_RADR_I_Z9002_20161019180400_O_DOR_SA_CAP.bin 435 | Z_RADR_I_Z9002_20161019181000_O_DOR_SA_CAP.bin 436 | Z_RADR_I_Z9002_20161019181600_O_DOR_SA_CAP.bin 437 | Z_RADR_I_Z9002_20161019182100_O_DOR_SA_CAP.bin 438 | Z_RADR_I_Z9002_20161019182700_O_DOR_SA_CAP.bin 439 | Z_RADR_I_Z9002_20161019183300_O_DOR_SA_CAP.bin 440 | Z_RADR_I_Z9002_20161019183800_O_DOR_SA_CAP.bin 441 | Z_RADR_I_Z9002_20161019184400_O_DOR_SA_CAP.bin 442 | Z_RADR_I_Z9002_20161019185000_O_DOR_SA_CAP.bin 443 | Z_RADR_I_Z9002_20161019185600_O_DOR_SA_CAP.bin 444 | Z_RADR_I_Z9002_20161019190100_O_DOR_SA_CAP.bin 445 | Z_RADR_I_Z9002_20161019190700_O_DOR_SA_CAP.bin 446 | Z_RADR_I_Z9002_20161019191300_O_DOR_SA_CAP.bin 447 | Z_RADR_I_Z9002_20161019191800_O_DOR_SA_CAP.bin 448 | Z_RADR_I_Z9002_20161019192400_O_DOR_SA_CAP.bin 449 | Z_RADR_I_Z9002_20161019193000_O_DOR_SA_CAP.bin 450 | Z_RADR_I_Z9002_20161019193600_O_DOR_SA_CAP.bin 451 | Z_RADR_I_Z9002_20161019194100_O_DOR_SA_CAP.bin 452 | Z_RADR_I_Z9002_20161019194700_O_DOR_SA_CAP.bin 453 | Z_RADR_I_Z9002_20161019195300_O_DOR_SA_CAP.bin 454 | Z_RADR_I_Z9002_20161019195800_O_DOR_SA_CAP.bin 455 | Z_RADR_I_Z9002_20161019200400_O_DOR_SA_CAP.bin 456 | Z_RADR_I_Z9002_20161019201000_O_DOR_SA_CAP.bin 457 | Z_RADR_I_Z9002_20161019201600_O_DOR_SA_CAP.bin 458 | Z_RADR_I_Z9002_20161019202100_O_DOR_SA_CAP.bin 459 | Z_RADR_I_Z9002_20161019202700_O_DOR_SA_CAP.bin 460 | Z_RADR_I_Z9002_20161019203300_O_DOR_SA_CAP.bin 461 | Z_RADR_I_Z9002_20161019203800_O_DOR_SA_CAP.bin 462 | Z_RADR_I_Z9002_20161019204400_O_DOR_SA_CAP.bin 463 | Z_RADR_I_Z9002_20161019205000_O_DOR_SA_CAP.bin 464 | Z_RADR_I_Z9002_20161019205600_O_DOR_SA_CAP.bin 465 | Z_RADR_I_Z9002_20161019210100_O_DOR_SA_CAP.bin 466 | Z_RADR_I_Z9002_20161019210700_O_DOR_SA_CAP.bin 467 | Z_RADR_I_Z9002_20161019211300_O_DOR_SA_CAP.bin 468 | Z_RADR_I_Z9002_20161019211800_O_DOR_SA_CAP.bin 469 | Z_RADR_I_Z9002_20161019212400_O_DOR_SA_CAP.bin 470 | Z_RADR_I_Z9002_20161019213000_O_DOR_SA_CAP.bin 471 | Z_RADR_I_Z9002_20161019213600_O_DOR_SA_CAP.bin 472 | Z_RADR_I_Z9002_20161019214100_O_DOR_SA_CAP.bin 473 | Z_RADR_I_Z9002_20161019214700_O_DOR_SA_CAP.bin 474 | Z_RADR_I_Z9002_20161019215300_O_DOR_SA_CAP.bin 475 | Z_RADR_I_Z9002_20161019215800_O_DOR_SA_CAP.bin 476 | Z_RADR_I_Z9002_20161019220400_O_DOR_SA_CAP.bin 477 | Z_RADR_I_Z9002_20161019221000_O_DOR_SA_CAP.bin 478 | Z_RADR_I_Z9002_20161019221600_O_DOR_SA_CAP.bin 479 | Z_RADR_I_Z9002_20161019222100_O_DOR_SA_CAP.bin 480 | Z_RADR_I_Z9002_20161019222700_O_DOR_SA_CAP.bin 481 | Z_RADR_I_Z9002_20161019223300_O_DOR_SA_CAP.bin 482 | Z_RADR_I_Z9002_20161019223800_O_DOR_SA_CAP.bin 483 | Z_RADR_I_Z9002_20161019224400_O_DOR_SA_CAP.bin 484 | Z_RADR_I_Z9002_20161019225000_O_DOR_SA_CAP.bin 485 | Z_RADR_I_Z9002_20161019225500_O_DOR_SA_CAP.bin 486 | Z_RADR_I_Z9002_20161019230100_O_DOR_SA_CAP.bin 487 | Z_RADR_I_Z9002_20161019230700_O_DOR_SA_CAP.bin 488 | Z_RADR_I_Z9002_20161019231300_O_DOR_SA_CAP.bin 489 | Z_RADR_I_Z9002_20161019231800_O_DOR_SA_CAP.bin 490 | Z_RADR_I_Z9002_20161019232400_O_DOR_SA_CAP.bin 491 | Z_RADR_I_Z9002_20161019233000_O_DOR_SA_CAP.bin 492 | Z_RADR_I_Z9002_20161019233500_O_DOR_SA_CAP.bin 493 | Z_RADR_I_Z9002_20161019234100_O_DOR_SA_CAP.bin 494 | Z_RADR_I_Z9002_20161019234700_O_DOR_SA_CAP.bin 495 | Z_RADR_I_Z9002_20161019235300_O_DOR_SA_CAP.bin 496 | Z_RADR_I_Z9002_20161019235800_O_DOR_SA_CAP.bin 497 | Z_RADR_I_Z9002_20161020000500_O_DOR_SA_CAP.bin 498 | Z_RADR_I_Z9002_20161020001000_O_DOR_SA_CAP.bin 499 | Z_RADR_I_Z9002_20161020001600_O_DOR_SA_CAP.bin 500 | Z_RADR_I_Z9002_20161020002200_O_DOR_SA_CAP.bin 501 | Z_RADR_I_Z9002_20161020002700_O_DOR_SA_CAP.bin 502 | Z_RADR_I_Z9002_20161020003300_O_DOR_SA_CAP.bin 503 | Z_RADR_I_Z9002_20161020003900_O_DOR_SA_CAP.bin 504 | Z_RADR_I_Z9002_20161020004400_O_DOR_SA_CAP.bin 505 | Z_RADR_I_Z9002_20161020005000_O_DOR_SA_CAP.bin 506 | Z_RADR_I_Z9002_20161020005600_O_DOR_SA_CAP.bin 507 | Z_RADR_I_Z9002_20161020010200_O_DOR_SA_CAP.bin 508 | Z_RADR_I_Z9002_20161020010700_O_DOR_SA_CAP.bin 509 | Z_RADR_I_Z9002_20161020011300_O_DOR_SA_CAP.bin 510 | Z_RADR_I_Z9002_20161020011900_O_DOR_SA_CAP.bin 511 | Z_RADR_I_Z9002_20161020012400_O_DOR_SA_CAP.bin 512 | Z_RADR_I_Z9002_20161020013000_O_DOR_SA_CAP.bin 513 | Z_RADR_I_Z9002_20161020013600_O_DOR_SA_CAP.bin 514 | Z_RADR_I_Z9002_20161020014200_O_DOR_SA_CAP.bin 515 | Z_RADR_I_Z9002_20161020014700_O_DOR_SA_CAP.bin 516 | Z_RADR_I_Z9002_20161020015300_O_DOR_SA_CAP.bin 517 | Z_RADR_I_Z9002_20161020015900_O_DOR_SA_CAP.bin 518 | Z_RADR_I_Z9002_20161020020400_O_DOR_SA_CAP.bin 519 | Z_RADR_I_Z9002_20161020021000_O_DOR_SA_CAP.bin 520 | Z_RADR_I_Z9002_20161020021600_O_DOR_SA_CAP.bin 521 | Z_RADR_I_Z9002_20161020022200_O_DOR_SA_CAP.bin 522 | Z_RADR_I_Z9002_20161020022700_O_DOR_SA_CAP.bin 523 | Z_RADR_I_Z9002_20161020023300_O_DOR_SA_CAP.bin 524 | Z_RADR_I_Z9002_20161020023900_O_DOR_SA_CAP.bin 525 | Z_RADR_I_Z9002_20161020024400_O_DOR_SA_CAP.bin 526 | Z_RADR_I_Z9002_20161020025000_O_DOR_SA_CAP.bin 527 | Z_RADR_I_Z9002_20161020025600_O_DOR_SA_CAP.bin 528 | Z_RADR_I_Z9002_20161020030200_O_DOR_SA_CAP.bin 529 | Z_RADR_I_Z9002_20161020030700_O_DOR_SA_CAP.bin 530 | Z_RADR_I_Z9002_20161020031300_O_DOR_SA_CAP.bin 531 | Z_RADR_I_Z9002_20161020031900_O_DOR_SA_CAP.bin 532 | Z_RADR_I_Z9002_20161020032400_O_DOR_SA_CAP.bin 533 | Z_RADR_I_Z9002_20161020033000_O_DOR_SA_CAP.bin 534 | Z_RADR_I_Z9002_20161020033600_O_DOR_SA_CAP.bin 535 | Z_RADR_I_Z9002_20161020034100_O_DOR_SA_CAP.bin 536 | Z_RADR_I_Z9002_20161020034700_O_DOR_SA_CAP.bin 537 | Z_RADR_I_Z9002_20161020035300_O_DOR_SA_CAP.bin 538 | Z_RADR_I_Z9002_20161020035900_O_DOR_SA_CAP.bin 539 | Z_RADR_I_Z9002_20161020040400_O_DOR_SA_CAP.bin 540 | Z_RADR_I_Z9002_20161020041000_O_DOR_SA_CAP.bin 541 | Z_RADR_I_Z9002_20161020041600_O_DOR_SA_CAP.bin 542 | Z_RADR_I_Z9002_20161020042100_O_DOR_SA_CAP.bin 543 | Z_RADR_I_Z9002_20161020042700_O_DOR_SA_CAP.bin 544 | Z_RADR_I_Z9002_20161020043300_O_DOR_SA_CAP.bin 545 | Z_RADR_I_Z9002_20161020043900_O_DOR_SA_CAP.bin 546 | Z_RADR_I_Z9002_20161020044400_O_DOR_SA_CAP.bin 547 | Z_RADR_I_Z9002_20161020045000_O_DOR_SA_CAP.bin 548 | Z_RADR_I_Z9002_20161020045600_O_DOR_SA_CAP.bin 549 | Z_RADR_I_Z9002_20161020050100_O_DOR_SA_CAP.bin 550 | Z_RADR_I_Z9002_20161020050700_O_DOR_SA_CAP.bin 551 | Z_RADR_I_Z9002_20161020051300_O_DOR_SA_CAP.bin 552 | Z_RADR_I_Z9002_20161020051900_O_DOR_SA_CAP.bin 553 | Z_RADR_I_Z9002_20161020052400_O_DOR_SA_CAP.bin 554 | Z_RADR_I_Z9002_20161020053000_O_DOR_SA_CAP.bin 555 | Z_RADR_I_Z9002_20161020053600_O_DOR_SA_CAP.bin 556 | Z_RADR_I_Z9002_20161020054100_O_DOR_SA_CAP.bin 557 | Z_RADR_I_Z9002_20161020054700_O_DOR_SA_CAP.bin 558 | Z_RADR_I_Z9002_20161020055300_O_DOR_SA_CAP.bin 559 | Z_RADR_I_Z9002_20161020055900_O_DOR_SA_CAP.bin 560 | Z_RADR_I_Z9002_20161020060400_O_DOR_SA_CAP.bin 561 | Z_RADR_I_Z9002_20161020061000_O_DOR_SA_CAP.bin 562 | Z_RADR_I_Z9002_20161020061600_O_DOR_SA_CAP.bin 563 | Z_RADR_I_Z9002_20161020062100_O_DOR_SA_CAP.bin 564 | Z_RADR_I_Z9002_20161020062700_O_DOR_SA_CAP.bin 565 | Z_RADR_I_Z9002_20161020063300_O_DOR_SA_CAP.bin 566 | Z_RADR_I_Z9002_20161020063900_O_DOR_SA_CAP.bin 567 | Z_RADR_I_Z9002_20161020064400_O_DOR_SA_CAP.bin 568 | Z_RADR_I_Z9002_20161020065000_O_DOR_SA_CAP.bin 569 | Z_RADR_I_Z9002_20161020065600_O_DOR_SA_CAP.bin 570 | Z_RADR_I_Z9002_20161020070100_O_DOR_SA_CAP.bin 571 | Z_RADR_I_Z9002_20161020070700_O_DOR_SA_CAP.bin 572 | Z_RADR_I_Z9002_20161020071300_O_DOR_SA_CAP.bin 573 | Z_RADR_I_Z9002_20161020071800_O_DOR_SA_CAP.bin 574 | Z_RADR_I_Z9002_20161020072400_O_DOR_SA_CAP.bin 575 | Z_RADR_I_Z9002_20161020073000_O_DOR_SA_CAP.bin 576 | Z_RADR_I_Z9002_20161020073600_O_DOR_SA_CAP.bin 577 | Z_RADR_I_Z9002_20161020074100_O_DOR_SA_CAP.bin 578 | Z_RADR_I_Z9002_20161020074700_O_DOR_SA_CAP.bin 579 | Z_RADR_I_Z9002_20161020075300_O_DOR_SA_CAP.bin 580 | Z_RADR_I_Z9002_20161020075800_O_DOR_SA_CAP.bin 581 | Z_RADR_I_Z9002_20161020080400_O_DOR_SA_CAP.bin 582 | Z_RADR_I_Z9002_20161020081000_O_DOR_SA_CAP.bin 583 | Z_RADR_I_Z9002_20161020081600_O_DOR_SA_CAP.bin 584 | Z_RADR_I_Z9002_20161020082200_O_DOR_SA_CAP.bin 585 | Z_RADR_I_Z9002_20161020082800_O_DOR_SA_CAP.bin 586 | Z_RADR_I_Z9002_20161020083300_O_DOR_SA_CAP.bin 587 | Z_RADR_I_Z9002_20161020083900_O_DOR_SA_CAP.bin 588 | Z_RADR_I_Z9002_20161020084500_O_DOR_SA_CAP.bin 589 | Z_RADR_I_Z9002_20161020085000_O_DOR_SA_CAP.bin 590 | Z_RADR_I_Z9002_20161020085600_O_DOR_SA_CAP.bin 591 | Z_RADR_I_Z9002_20161020090200_O_DOR_SA_CAP.bin 592 | Z_RADR_I_Z9002_20161020090800_O_DOR_SA_CAP.bin 593 | Z_RADR_I_Z9002_20161020091300_O_DOR_SA_CAP.bin 594 | Z_RADR_I_Z9002_20161020091900_O_DOR_SA_CAP.bin 595 | Z_RADR_I_Z9002_20161020092500_O_DOR_SA_CAP.bin 596 | Z_RADR_I_Z9002_20161020093000_O_DOR_SA_CAP.bin 597 | Z_RADR_I_Z9002_20161020093600_O_DOR_SA_CAP.bin 598 | Z_RADR_I_Z9002_20161020094200_O_DOR_SA_CAP.bin 599 | Z_RADR_I_Z9002_20161020094700_O_DOR_SA_CAP.bin 600 | Z_RADR_I_Z9002_20161020095300_O_DOR_SA_CAP.bin 601 | Z_RADR_I_Z9002_20161020095900_O_DOR_SA_CAP.bin 602 | Z_RADR_I_Z9002_20161020100500_O_DOR_SA_CAP.bin 603 | Z_RADR_I_Z9002_20161020101000_O_DOR_SA_CAP.bin 604 | Z_RADR_I_Z9002_20161020101600_O_DOR_SA_CAP.bin 605 | Z_RADR_I_Z9002_20161020102200_O_DOR_SA_CAP.bin 606 | Z_RADR_I_Z9002_20161020102700_O_DOR_SA_CAP.bin 607 | Z_RADR_I_Z9002_20161020103300_O_DOR_SA_CAP.bin 608 | Z_RADR_I_Z9002_20161020103900_O_DOR_SA_CAP.bin 609 | Z_RADR_I_Z9002_20161020104500_O_DOR_SA_CAP.bin 610 | Z_RADR_I_Z9002_20161020105000_O_DOR_SA_CAP.bin 611 | Z_RADR_I_Z9002_20161020105600_O_DOR_SA_CAP.bin 612 | Z_RADR_I_Z9002_20161020110200_O_DOR_SA_CAP.bin 613 | Z_RADR_I_Z9002_20161020110700_O_DOR_SA_CAP.bin 614 | Z_RADR_I_Z9002_20161020111300_O_DOR_SA_CAP.bin 615 | Z_RADR_I_Z9002_20161020111900_O_DOR_SA_CAP.bin 616 | Z_RADR_I_Z9002_20161020112500_O_DOR_SA_CAP.bin 617 | Z_RADR_I_Z9002_20161020113000_O_DOR_SA_CAP.bin 618 | Z_RADR_I_Z9002_20161020113600_O_DOR_SA_CAP.bin 619 | Z_RADR_I_Z9002_20161020114200_O_DOR_SA_CAP.bin 620 | Z_RADR_I_Z9002_20161020114700_O_DOR_SA_CAP.bin 621 | Z_RADR_I_Z9002_20161020115300_O_DOR_SA_CAP.bin 622 | Z_RADR_I_Z9002_20161020115900_O_DOR_SA_CAP.bin 623 | Z_RADR_I_Z9002_20161020120500_O_DOR_SA_CAP.bin 624 | Z_RADR_I_Z9002_20161020121000_O_DOR_SA_CAP.bin 625 | Z_RADR_I_Z9002_20161020121600_O_DOR_SA_CAP.bin 626 | Z_RADR_I_Z9002_20161020122200_O_DOR_SA_CAP.bin 627 | Z_RADR_I_Z9002_20161020122700_O_DOR_SA_CAP.bin 628 | Z_RADR_I_Z9002_20161020123300_O_DOR_SA_CAP.bin 629 | Z_RADR_I_Z9002_20161020123900_O_DOR_SA_CAP.bin 630 | Z_RADR_I_Z9002_20161020124400_O_DOR_SA_CAP.bin 631 | Z_RADR_I_Z9002_20161020125000_O_DOR_SA_CAP.bin 632 | Z_RADR_I_Z9002_20161020125600_O_DOR_SA_CAP.bin 633 | Z_RADR_I_Z9002_20161020130200_O_DOR_SA_CAP.bin 634 | Z_RADR_I_Z9002_20161020130700_O_DOR_SA_CAP.bin 635 | Z_RADR_I_Z9002_20161020131300_O_DOR_SA_CAP.bin 636 | Z_RADR_I_Z9002_20161020131900_O_DOR_SA_CAP.bin 637 | Z_RADR_I_Z9002_20161020132400_O_DOR_SA_CAP.bin 638 | Z_RADR_I_Z9002_20161020133000_O_DOR_SA_CAP.bin 639 | Z_RADR_I_Z9002_20161020133600_O_DOR_SA_CAP.bin 640 | Z_RADR_I_Z9002_20161020134200_O_DOR_SA_CAP.bin 641 | Z_RADR_I_Z9002_20161020134700_O_DOR_SA_CAP.bin 642 | Z_RADR_I_Z9002_20161020135300_O_DOR_SA_CAP.bin 643 | Z_RADR_I_Z9002_20161020135900_O_DOR_SA_CAP.bin 644 | Z_RADR_I_Z9002_20161020140400_O_DOR_SA_CAP.bin 645 | Z_RADR_I_Z9002_20161020141000_O_DOR_SA_CAP.bin 646 | Z_RADR_I_Z9002_20161020141600_O_DOR_SA_CAP.bin 647 | Z_RADR_I_Z9002_20161020142100_O_DOR_SA_CAP.bin 648 | Z_RADR_I_Z9002_20161020142700_O_DOR_SA_CAP.bin 649 | Z_RADR_I_Z9002_20161020143300_O_DOR_SA_CAP.bin 650 | Z_RADR_I_Z9002_20161020143900_O_DOR_SA_CAP.bin 651 | Z_RADR_I_Z9002_20161020144400_O_DOR_SA_CAP.bin 652 | Z_RADR_I_Z9002_20161020145000_O_DOR_SA_CAP.bin 653 | Z_RADR_I_Z9002_20161020145600_O_DOR_SA_CAP.bin 654 | Z_RADR_I_Z9002_20161020150100_O_DOR_SA_CAP.bin 655 | Z_RADR_I_Z9002_20161020150700_O_DOR_SA_CAP.bin 656 | Z_RADR_I_Z9002_20161020151300_O_DOR_SA_CAP.bin 657 | Z_RADR_I_Z9002_20161020151900_O_DOR_SA_CAP.bin 658 | Z_RADR_I_Z9002_20161020152400_O_DOR_SA_CAP.bin 659 | Z_RADR_I_Z9002_20161020153000_O_DOR_SA_CAP.bin 660 | Z_RADR_I_Z9002_20161020153600_O_DOR_SA_CAP.bin 661 | Z_RADR_I_Z9002_20161020154100_O_DOR_SA_CAP.bin 662 | Z_RADR_I_Z9002_20161020154700_O_DOR_SA_CAP.bin 663 | Z_RADR_I_Z9002_20161020155300_O_DOR_SA_CAP.bin 664 | Z_RADR_I_Z9002_20161020155900_O_DOR_SA_CAP.bin 665 | Z_RADR_I_Z9002_20161020160400_O_DOR_SA_CAP.bin 666 | Z_RADR_I_Z9002_20161020161000_O_DOR_SA_CAP.bin 667 | Z_RADR_I_Z9002_20161020161600_O_DOR_SA_CAP.bin 668 | Z_RADR_I_Z9002_20161020162200_O_DOR_SA_CAP.bin 669 | Z_RADR_I_Z9002_20161020162800_O_DOR_SA_CAP.bin 670 | Z_RADR_I_Z9002_20161020163300_O_DOR_SA_CAP.bin 671 | Z_RADR_I_Z9002_20161020163900_O_DOR_SA_CAP.bin 672 | Z_RADR_I_Z9002_20161020164500_O_DOR_SA_CAP.bin 673 | Z_RADR_I_Z9002_20161020165000_O_DOR_SA_CAP.bin 674 | Z_RADR_I_Z9002_20161020165600_O_DOR_SA_CAP.bin 675 | Z_RADR_I_Z9002_20161020170200_O_DOR_SA_CAP.bin 676 | Z_RADR_I_Z9002_20161020170800_O_DOR_SA_CAP.bin 677 | Z_RADR_I_Z9002_20161020171300_O_DOR_SA_CAP.bin 678 | Z_RADR_I_Z9002_20161020171900_O_DOR_SA_CAP.bin 679 | Z_RADR_I_Z9002_20161020172500_O_DOR_SA_CAP.bin 680 | Z_RADR_I_Z9002_20161020173000_O_DOR_SA_CAP.bin 681 | Z_RADR_I_Z9002_20161020173600_O_DOR_SA_CAP.bin 682 | Z_RADR_I_Z9002_20161020174200_O_DOR_SA_CAP.bin 683 | Z_RADR_I_Z9002_20161020174800_O_DOR_SA_CAP.bin 684 | Z_RADR_I_Z9002_20161020175300_O_DOR_SA_CAP.bin 685 | Z_RADR_I_Z9002_20161020175900_O_DOR_SA_CAP.bin 686 | Z_RADR_I_Z9002_20161020180500_O_DOR_SA_CAP.bin 687 | Z_RADR_I_Z9002_20161020181000_O_DOR_SA_CAP.bin 688 | Z_RADR_I_Z9002_20161020181600_O_DOR_SA_CAP.bin 689 | Z_RADR_I_Z9002_20161020182200_O_DOR_SA_CAP.bin 690 | Z_RADR_I_Z9002_20161020182800_O_DOR_SA_CAP.bin 691 | Z_RADR_I_Z9002_20161020183300_O_DOR_SA_CAP.bin 692 | Z_RADR_I_Z9002_20161020183900_O_DOR_SA_CAP.bin 693 | Z_RADR_I_Z9002_20161020184500_O_DOR_SA_CAP.bin 694 | Z_RADR_I_Z9002_20161020185000_O_DOR_SA_CAP.bin 695 | Z_RADR_I_Z9002_20161020185600_O_DOR_SA_CAP.bin 696 | Z_RADR_I_Z9002_20161020190200_O_DOR_SA_CAP.bin 697 | Z_RADR_I_Z9002_20161020190800_O_DOR_SA_CAP.bin 698 | Z_RADR_I_Z9002_20161020191300_O_DOR_SA_CAP.bin 699 | Z_RADR_I_Z9002_20161020191900_O_DOR_SA_CAP.bin 700 | Z_RADR_I_Z9002_20161020192500_O_DOR_SA_CAP.bin 701 | Z_RADR_I_Z9002_20161020193000_O_DOR_SA_CAP.bin 702 | Z_RADR_I_Z9002_20161020193600_O_DOR_SA_CAP.bin 703 | Z_RADR_I_Z9002_20161020194200_O_DOR_SA_CAP.bin 704 | Z_RADR_I_Z9002_20161020194800_O_DOR_SA_CAP.bin 705 | Z_RADR_I_Z9002_20161020195300_O_DOR_SA_CAP.bin 706 | Z_RADR_I_Z9002_20161020195900_O_DOR_SA_CAP.bin 707 | Z_RADR_I_Z9002_20161020200500_O_DOR_SA_CAP.bin 708 | Z_RADR_I_Z9002_20161020201000_O_DOR_SA_CAP.bin 709 | Z_RADR_I_Z9002_20161020201600_O_DOR_SA_CAP.bin 710 | Z_RADR_I_Z9002_20161020202200_O_DOR_SA_CAP.bin 711 | Z_RADR_I_Z9002_20161020202800_O_DOR_SA_CAP.bin 712 | Z_RADR_I_Z9002_20161020203300_O_DOR_SA_CAP.bin 713 | Z_RADR_I_Z9002_20161020203900_O_DOR_SA_CAP.bin 714 | Z_RADR_I_Z9002_20161020204500_O_DOR_SA_CAP.bin 715 | Z_RADR_I_Z9002_20161020205000_O_DOR_SA_CAP.bin 716 | Z_RADR_I_Z9002_20161020205600_O_DOR_SA_CAP.bin 717 | Z_RADR_I_Z9002_20161020210200_O_DOR_SA_CAP.bin 718 | Z_RADR_I_Z9002_20161020210700_O_DOR_SA_CAP.bin 719 | Z_RADR_I_Z9002_20161020211300_O_DOR_SA_CAP.bin 720 | Z_RADR_I_Z9002_20161020211900_O_DOR_SA_CAP.bin 721 | Z_RADR_I_Z9002_20161020212500_O_DOR_SA_CAP.bin 722 | Z_RADR_I_Z9002_20161020213000_O_DOR_SA_CAP.bin 723 | Z_RADR_I_Z9002_20161020213600_O_DOR_SA_CAP.bin 724 | Z_RADR_I_Z9002_20161020214200_O_DOR_SA_CAP.bin 725 | Z_RADR_I_Z9002_20161020214700_O_DOR_SA_CAP.bin 726 | Z_RADR_I_Z9002_20161020215300_O_DOR_SA_CAP.bin 727 | Z_RADR_I_Z9002_20161020215900_O_DOR_SA_CAP.bin 728 | Z_RADR_I_Z9002_20161020220500_O_DOR_SA_CAP.bin 729 | Z_RADR_I_Z9002_20161020221000_O_DOR_SA_CAP.bin 730 | Z_RADR_I_Z9002_20161020221600_O_DOR_SA_CAP.bin 731 | Z_RADR_I_Z9002_20161020222200_O_DOR_SA_CAP.bin 732 | Z_RADR_I_Z9002_20161020222700_O_DOR_SA_CAP.bin 733 | Z_RADR_I_Z9002_20161020223300_O_DOR_SA_CAP.bin 734 | Z_RADR_I_Z9002_20161020223900_O_DOR_SA_CAP.bin 735 | Z_RADR_I_Z9002_20161020224500_O_DOR_SA_CAP.bin 736 | Z_RADR_I_Z9002_20161020225000_O_DOR_SA_CAP.bin 737 | Z_RADR_I_Z9002_20161020225600_O_DOR_SA_CAP.bin 738 | Z_RADR_I_Z9002_20161020230200_O_DOR_SA_CAP.bin 739 | Z_RADR_I_Z9002_20161020230700_O_DOR_SA_CAP.bin 740 | Z_RADR_I_Z9002_20161020231300_O_DOR_SA_CAP.bin 741 | Z_RADR_I_Z9002_20161020231900_O_DOR_SA_CAP.bin 742 | Z_RADR_I_Z9002_20161020232500_O_DOR_SA_CAP.bin 743 | Z_RADR_I_Z9002_20161020233000_O_DOR_SA_CAP.bin 744 | Z_RADR_I_Z9002_20161020233600_O_DOR_SA_CAP.bin 745 | Z_RADR_I_Z9002_20161020234200_O_DOR_SA_CAP.bin 746 | Z_RADR_I_Z9002_20161020234700_O_DOR_SA_CAP.bin 747 | Z_RADR_I_Z9002_20161020235300_O_DOR_SA_CAP.bin 748 | Z_RADR_I_Z9002_20161020235900_O_DOR_SA_CAP.bin 749 | Z_RADR_I_Z9002_20161021000500_O_DOR_SA_CAP.bin 750 | Z_RADR_I_Z9002_20161021001100_O_DOR_SA_CAP.bin 751 | Z_RADR_I_Z9002_20161021001600_O_DOR_SA_CAP.bin 752 | Z_RADR_I_Z9002_20161021002200_O_DOR_SA_CAP.bin 753 | Z_RADR_I_Z9002_20161021002800_O_DOR_SA_CAP.bin 754 | Z_RADR_I_Z9002_20161021003400_O_DOR_SA_CAP.bin 755 | Z_RADR_I_Z9002_20161021003900_O_DOR_SA_CAP.bin 756 | Z_RADR_I_Z9002_20161021004500_O_DOR_SA_CAP.bin 757 | Z_RADR_I_Z9002_20161021005100_O_DOR_SA_CAP.bin 758 | Z_RADR_I_Z9002_20161021005600_O_DOR_SA_CAP.bin 759 | Z_RADR_I_Z9002_20161021010200_O_DOR_SA_CAP.bin 760 | Z_RADR_I_Z9002_20161021010800_O_DOR_SA_CAP.bin 761 | Z_RADR_I_Z9002_20161021011400_O_DOR_SA_CAP.bin 762 | Z_RADR_I_Z9002_20161021011900_O_DOR_SA_CAP.bin 763 | Z_RADR_I_Z9002_20161021012500_O_DOR_SA_CAP.bin 764 | Z_RADR_I_Z9002_20161021013100_O_DOR_SA_CAP.bin 765 | Z_RADR_I_Z9002_20161021013600_O_DOR_SA_CAP.bin 766 | Z_RADR_I_Z9002_20161021014200_O_DOR_SA_CAP.bin 767 | Z_RADR_I_Z9002_20161021014800_O_DOR_SA_CAP.bin 768 | Z_RADR_I_Z9002_20161021015300_O_DOR_SA_CAP.bin 769 | Z_RADR_I_Z9002_20161021015900_O_DOR_SA_CAP.bin 770 | Z_RADR_I_Z9002_20161021020500_O_DOR_SA_CAP.bin 771 | Z_RADR_I_Z9002_20161021021100_O_DOR_SA_CAP.bin 772 | Z_RADR_I_Z9002_20161021021600_O_DOR_SA_CAP.bin 773 | Z_RADR_I_Z9002_20161021022200_O_DOR_SA_CAP.bin 774 | Z_RADR_I_Z9002_20161021022800_O_DOR_SA_CAP.bin 775 | Z_RADR_I_Z9002_20161021023300_O_DOR_SA_CAP.bin 776 | Z_RADR_I_Z9002_20161021023900_O_DOR_SA_CAP.bin 777 | Z_RADR_I_Z9002_20161021024500_O_DOR_SA_CAP.bin 778 | Z_RADR_I_Z9002_20161021025100_O_DOR_SA_CAP.bin 779 | Z_RADR_I_Z9002_20161021025600_O_DOR_SA_CAP.bin 780 | Z_RADR_I_Z9002_20161021030200_O_DOR_SA_CAP.bin 781 | Z_RADR_I_Z9002_20161021030800_O_DOR_SA_CAP.bin 782 | Z_RADR_I_Z9002_20161021031300_O_DOR_SA_CAP.bin 783 | Z_RADR_I_Z9002_20161021031900_O_DOR_SA_CAP.bin 784 | Z_RADR_I_Z9002_20161021032500_O_DOR_SA_CAP.bin 785 | Z_RADR_I_Z9002_20161021033100_O_DOR_SA_CAP.bin 786 | Z_RADR_I_Z9002_20161021033600_O_DOR_SA_CAP.bin 787 | Z_RADR_I_Z9002_20161021034200_O_DOR_SA_CAP.bin 788 | Z_RADR_I_Z9002_20161021034800_O_DOR_SA_CAP.bin 789 | Z_RADR_I_Z9002_20161021035300_O_DOR_SA_CAP.bin 790 | Z_RADR_I_Z9002_20161021035900_O_DOR_SA_CAP.bin 791 | Z_RADR_I_Z9002_20161021040500_O_DOR_SA_CAP.bin 792 | Z_RADR_I_Z9002_20161021041000_O_DOR_SA_CAP.bin 793 | Z_RADR_I_Z9002_20161021041600_O_DOR_SA_CAP.bin 794 | Z_RADR_I_Z9002_20161021042200_O_DOR_SA_CAP.bin 795 | Z_RADR_I_Z9002_20161021042800_O_DOR_SA_CAP.bin 796 | Z_RADR_I_Z9002_20161021043300_O_DOR_SA_CAP.bin 797 | Z_RADR_I_Z9002_20161021043900_O_DOR_SA_CAP.bin 798 | Z_RADR_I_Z9002_20161021044500_O_DOR_SA_CAP.bin 799 | Z_RADR_I_Z9002_20161021045000_O_DOR_SA_CAP.bin 800 | Z_RADR_I_Z9002_20161021045600_O_DOR_SA_CAP.bin 801 | Z_RADR_I_Z9002_20161021050200_O_DOR_SA_CAP.bin 802 | Z_RADR_I_Z9002_20161021050800_O_DOR_SA_CAP.bin 803 | Z_RADR_I_Z9002_20161021051300_O_DOR_SA_CAP.bin 804 | Z_RADR_I_Z9002_20161021051900_O_DOR_SA_CAP.bin 805 | Z_RADR_I_Z9002_20161021052500_O_DOR_SA_CAP.bin 806 | Z_RADR_I_Z9002_20161021053000_O_DOR_SA_CAP.bin 807 | Z_RADR_I_Z9002_20161021053600_O_DOR_SA_CAP.bin 808 | Z_RADR_I_Z9002_20161021054200_O_DOR_SA_CAP.bin 809 | Z_RADR_I_Z9002_20161021054700_O_DOR_SA_CAP.bin 810 | Z_RADR_I_Z9002_20161021055300_O_DOR_SA_CAP.bin 811 | Z_RADR_I_Z9002_20161021055900_O_DOR_SA_CAP.bin 812 | Z_RADR_I_Z9002_20161021060500_O_DOR_SA_CAP.bin 813 | Z_RADR_I_Z9002_20161021061000_O_DOR_SA_CAP.bin 814 | Z_RADR_I_Z9002_20161021061600_O_DOR_SA_CAP.bin 815 | Z_RADR_I_Z9002_20161021062200_O_DOR_SA_CAP.bin 816 | Z_RADR_I_Z9002_20161021062700_O_DOR_SA_CAP.bin 817 | Z_RADR_I_Z9002_20161021063300_O_DOR_SA_CAP.bin 818 | Z_RADR_I_Z9002_20161021063900_O_DOR_SA_CAP.bin 819 | Z_RADR_I_Z9002_20161021064500_O_DOR_SA_CAP.bin 820 | Z_RADR_I_Z9002_20161021065000_O_DOR_SA_CAP.bin 821 | Z_RADR_I_Z9002_20161021065600_O_DOR_SA_CAP.bin 822 | Z_RADR_I_Z9002_20161021070200_O_DOR_SA_CAP.bin 823 | Z_RADR_I_Z9002_20161021070700_O_DOR_SA_CAP.bin 824 | Z_RADR_I_Z9002_20161021071300_O_DOR_SA_CAP.bin 825 | Z_RADR_I_Z9002_20161021071900_O_DOR_SA_CAP.bin 826 | Z_RADR_I_Z9002_20161021072500_O_DOR_SA_CAP.bin 827 | Z_RADR_I_Z9002_20161021073000_O_DOR_SA_CAP.bin 828 | Z_RADR_I_Z9002_20161021073600_O_DOR_SA_CAP.bin 829 | Z_RADR_I_Z9002_20161021074200_O_DOR_SA_CAP.bin 830 | Z_RADR_I_Z9002_20161021074700_O_DOR_SA_CAP.bin 831 | Z_RADR_I_Z9002_20161021075300_O_DOR_SA_CAP.bin 832 | Z_RADR_I_Z9002_20161021075900_O_DOR_SA_CAP.bin 833 | Z_RADR_I_Z9002_20161021080500_O_DOR_SA_CAP.bin 834 | Z_RADR_I_Z9002_20161021081100_O_DOR_SA_CAP.bin 835 | Z_RADR_I_Z9002_20161021081600_O_DOR_SA_CAP.bin 836 | Z_RADR_I_Z9002_20161021082200_O_DOR_SA_CAP.bin 837 | Z_RADR_I_Z9002_20161021082800_O_DOR_SA_CAP.bin 838 | Z_RADR_I_Z9002_20161021083400_O_DOR_SA_CAP.bin 839 | Z_RADR_I_Z9002_20161021083900_O_DOR_SA_CAP.bin 840 | Z_RADR_I_Z9002_20161021084500_O_DOR_SA_CAP.bin 841 | Z_RADR_I_Z9002_20161021085100_O_DOR_SA_CAP.bin 842 | Z_RADR_I_Z9002_20161021085600_O_DOR_SA_CAP.bin 843 | Z_RADR_I_Z9002_20161021090200_O_DOR_SA_CAP.bin 844 | Z_RADR_I_Z9002_20161021090800_O_DOR_SA_CAP.bin 845 | Z_RADR_I_Z9002_20161021091400_O_DOR_SA_CAP.bin 846 | Z_RADR_I_Z9002_20161021091900_O_DOR_SA_CAP.bin 847 | Z_RADR_I_Z9002_20161021092500_O_DOR_SA_CAP.bin 848 | Z_RADR_I_Z9002_20161021093100_O_DOR_SA_CAP.bin 849 | Z_RADR_I_Z9002_20161021093600_O_DOR_SA_CAP.bin 850 | Z_RADR_I_Z9002_20161021094200_O_DOR_SA_CAP.bin 851 | Z_RADR_I_Z9002_20161021094800_O_DOR_SA_CAP.bin 852 | Z_RADR_I_Z9002_20161021095400_O_DOR_SA_CAP.bin 853 | Z_RADR_I_Z9002_20161021095900_O_DOR_SA_CAP.bin 854 | Z_RADR_I_Z9002_20161021100500_O_DOR_SA_CAP.bin 855 | Z_RADR_I_Z9002_20161021101100_O_DOR_SA_CAP.bin 856 | Z_RADR_I_Z9002_20161021101600_O_DOR_SA_CAP.bin 857 | Z_RADR_I_Z9002_20161021102200_O_DOR_SA_CAP.bin 858 | Z_RADR_I_Z9002_20161021102800_O_DOR_SA_CAP.bin 859 | Z_RADR_I_Z9002_20161021103300_O_DOR_SA_CAP.bin 860 | Z_RADR_I_Z9002_20161021103900_O_DOR_SA_CAP.bin 861 | Z_RADR_I_Z9002_20161021104500_O_DOR_SA_CAP.bin 862 | Z_RADR_I_Z9002_20161021105100_O_DOR_SA_CAP.bin 863 | Z_RADR_I_Z9002_20161021105600_O_DOR_SA_CAP.bin 864 | Z_RADR_I_Z9002_20161021110200_O_DOR_SA_CAP.bin 865 | Z_RADR_I_Z9002_20161021110800_O_DOR_SA_CAP.bin 866 | Z_RADR_I_Z9002_20161021111300_O_DOR_SA_CAP.bin 867 | Z_RADR_I_Z9002_20161021111900_O_DOR_SA_CAP.bin 868 | Z_RADR_I_Z9002_20161021112500_O_DOR_SA_CAP.bin 869 | Z_RADR_I_Z9002_20161021113100_O_DOR_SA_CAP.bin 870 | Z_RADR_I_Z9002_20161021113600_O_DOR_SA_CAP.bin 871 | Z_RADR_I_Z9002_20161021114200_O_DOR_SA_CAP.bin 872 | Z_RADR_I_Z9002_20161021114800_O_DOR_SA_CAP.bin 873 | Z_RADR_I_Z9002_20161021115300_O_DOR_SA_CAP.bin 874 | Z_RADR_I_Z9002_20161021115900_O_DOR_SA_CAP.bin 875 | Z_RADR_I_Z9002_20161021120500_O_DOR_SA_CAP.bin 876 | Z_RADR_I_Z9002_20161021121000_O_DOR_SA_CAP.bin 877 | Z_RADR_I_Z9002_20161021121600_O_DOR_SA_CAP.bin 878 | Z_RADR_I_Z9002_20161021122200_O_DOR_SA_CAP.bin 879 | Z_RADR_I_Z9002_20161021122800_O_DOR_SA_CAP.bin 880 | Z_RADR_I_Z9002_20161021123300_O_DOR_SA_CAP.bin 881 | Z_RADR_I_Z9002_20161021123900_O_DOR_SA_CAP.bin 882 | Z_RADR_I_Z9002_20161021124500_O_DOR_SA_CAP.bin 883 | Z_RADR_I_Z9002_20161021125000_O_DOR_SA_CAP.bin 884 | Z_RADR_I_Z9002_20161021125600_O_DOR_SA_CAP.bin 885 | Z_RADR_I_Z9002_20161021130200_O_DOR_SA_CAP.bin 886 | Z_RADR_I_Z9002_20161021130800_O_DOR_SA_CAP.bin 887 | Z_RADR_I_Z9002_20161021131300_O_DOR_SA_CAP.bin 888 | Z_RADR_I_Z9002_20161021131900_O_DOR_SA_CAP.bin 889 | Z_RADR_I_Z9002_20161021132500_O_DOR_SA_CAP.bin 890 | Z_RADR_I_Z9002_20161021133000_O_DOR_SA_CAP.bin 891 | Z_RADR_I_Z9002_20161021133600_O_DOR_SA_CAP.bin 892 | Z_RADR_I_Z9002_20161021134200_O_DOR_SA_CAP.bin 893 | Z_RADR_I_Z9002_20161021134700_O_DOR_SA_CAP.bin 894 | Z_RADR_I_Z9002_20161021135300_O_DOR_SA_CAP.bin 895 | Z_RADR_I_Z9002_20161021135900_O_DOR_SA_CAP.bin 896 | Z_RADR_I_Z9002_20161021140500_O_DOR_SA_CAP.bin 897 | Z_RADR_I_Z9002_20161021141000_O_DOR_SA_CAP.bin 898 | Z_RADR_I_Z9002_20161021141600_O_DOR_SA_CAP.bin 899 | Z_RADR_I_Z9002_20161021142200_O_DOR_SA_CAP.bin 900 | Z_RADR_I_Z9002_20161021142800_O_DOR_SA_CAP.bin 901 | Z_RADR_I_Z9002_20161021143300_O_DOR_SA_CAP.bin 902 | Z_RADR_I_Z9002_20161021143900_O_DOR_SA_CAP.bin 903 | Z_RADR_I_Z9002_20161021144500_O_DOR_SA_CAP.bin 904 | Z_RADR_I_Z9002_20161021145000_O_DOR_SA_CAP.bin 905 | Z_RADR_I_Z9002_20161021145600_O_DOR_SA_CAP.bin 906 | Z_RADR_I_Z9002_20161021150200_O_DOR_SA_CAP.bin 907 | Z_RADR_I_Z9002_20161021150700_O_DOR_SA_CAP.bin 908 | Z_RADR_I_Z9002_20161021151300_O_DOR_SA_CAP.bin 909 | Z_RADR_I_Z9002_20161021151900_O_DOR_SA_CAP.bin 910 | Z_RADR_I_Z9002_20161021152500_O_DOR_SA_CAP.bin 911 | Z_RADR_I_Z9002_20161021153000_O_DOR_SA_CAP.bin 912 | Z_RADR_I_Z9002_20161021153600_O_DOR_SA_CAP.bin 913 | Z_RADR_I_Z9002_20161021154200_O_DOR_SA_CAP.bin 914 | Z_RADR_I_Z9002_20161021154700_O_DOR_SA_CAP.bin 915 | Z_RADR_I_Z9002_20161021155300_O_DOR_SA_CAP.bin 916 | Z_RADR_I_Z9002_20161021155900_O_DOR_SA_CAP.bin 917 | Z_RADR_I_Z9002_20161021160500_O_DOR_SA_CAP.bin 918 | Z_RADR_I_Z9002_20161021161000_O_DOR_SA_CAP.bin 919 | Z_RADR_I_Z9002_20161021161700_O_DOR_SA_CAP.bin 920 | Z_RADR_I_Z9002_20161021162200_O_DOR_SA_CAP.bin 921 | Z_RADR_I_Z9002_20161021162800_O_DOR_SA_CAP.bin 922 | Z_RADR_I_Z9002_20161021163400_O_DOR_SA_CAP.bin 923 | Z_RADR_I_Z9002_20161021163900_O_DOR_SA_CAP.bin 924 | Z_RADR_I_Z9002_20161021164500_O_DOR_SA_CAP.bin 925 | Z_RADR_I_Z9002_20161021165100_O_DOR_SA_CAP.bin 926 | Z_RADR_I_Z9002_20161021165600_O_DOR_SA_CAP.bin 927 | Z_RADR_I_Z9002_20161021170200_O_DOR_SA_CAP.bin 928 | Z_RADR_I_Z9002_20161021170800_O_DOR_SA_CAP.bin 929 | Z_RADR_I_Z9002_20161021171400_O_DOR_SA_CAP.bin 930 | Z_RADR_I_Z9002_20161021171900_O_DOR_SA_CAP.bin 931 | Z_RADR_I_Z9002_20161021172500_O_DOR_SA_CAP.bin 932 | Z_RADR_I_Z9002_20161021173100_O_DOR_SA_CAP.bin 933 | Z_RADR_I_Z9002_20161021173600_O_DOR_SA_CAP.bin 934 | Z_RADR_I_Z9002_20161021174200_O_DOR_SA_CAP.bin 935 | Z_RADR_I_Z9002_20161021174800_O_DOR_SA_CAP.bin 936 | Z_RADR_I_Z9002_20161021175400_O_DOR_SA_CAP.bin 937 | Z_RADR_I_Z9002_20161021175900_O_DOR_SA_CAP.bin 938 | Z_RADR_I_Z9002_20161021180500_O_DOR_SA_CAP.bin 939 | Z_RADR_I_Z9002_20161021181100_O_DOR_SA_CAP.bin 940 | Z_RADR_I_Z9002_20161021181600_O_DOR_SA_CAP.bin 941 | Z_RADR_I_Z9002_20161021182200_O_DOR_SA_CAP.bin 942 | Z_RADR_I_Z9002_20161021182800_O_DOR_SA_CAP.bin 943 | Z_RADR_I_Z9002_20161021183400_O_DOR_SA_CAP.bin 944 | Z_RADR_I_Z9002_20161021183900_O_DOR_SA_CAP.bin 945 | Z_RADR_I_Z9002_20161021184500_O_DOR_SA_CAP.bin 946 | Z_RADR_I_Z9002_20161021185100_O_DOR_SA_CAP.bin 947 | Z_RADR_I_Z9002_20161021185600_O_DOR_SA_CAP.bin 948 | Z_RADR_I_Z9002_20161021190200_O_DOR_SA_CAP.bin 949 | Z_RADR_I_Z9002_20161021190800_O_DOR_SA_CAP.bin 950 | Z_RADR_I_Z9002_20161021191400_O_DOR_SA_CAP.bin 951 | Z_RADR_I_Z9002_20161021191900_O_DOR_SA_CAP.bin 952 | Z_RADR_I_Z9002_20161021192500_O_DOR_SA_CAP.bin 953 | Z_RADR_I_Z9002_20161021193100_O_DOR_SA_CAP.bin 954 | Z_RADR_I_Z9002_20161021193600_O_DOR_SA_CAP.bin 955 | Z_RADR_I_Z9002_20161021194200_O_DOR_SA_CAP.bin 956 | Z_RADR_I_Z9002_20161021194800_O_DOR_SA_CAP.bin 957 | Z_RADR_I_Z9002_20161021195400_O_DOR_SA_CAP.bin 958 | Z_RADR_I_Z9002_20161021195900_O_DOR_SA_CAP.bin 959 | Z_RADR_I_Z9002_20161021200500_O_DOR_SA_CAP.bin 960 | Z_RADR_I_Z9002_20161021201100_O_DOR_SA_CAP.bin 961 | Z_RADR_I_Z9002_20161021201600_O_DOR_SA_CAP.bin 962 | Z_RADR_I_Z9002_20161021202200_O_DOR_SA_CAP.bin 963 | Z_RADR_I_Z9002_20161021202800_O_DOR_SA_CAP.bin 964 | Z_RADR_I_Z9002_20161021203300_O_DOR_SA_CAP.bin 965 | Z_RADR_I_Z9002_20161021203900_O_DOR_SA_CAP.bin 966 | Z_RADR_I_Z9002_20161021204500_O_DOR_SA_CAP.bin 967 | Z_RADR_I_Z9002_20161021205100_O_DOR_SA_CAP.bin 968 | Z_RADR_I_Z9002_20161021205600_O_DOR_SA_CAP.bin 969 | Z_RADR_I_Z9002_20161021210200_O_DOR_SA_CAP.bin 970 | Z_RADR_I_Z9002_20161021210800_O_DOR_SA_CAP.bin 971 | Z_RADR_I_Z9002_20161021211300_O_DOR_SA_CAP.bin 972 | Z_RADR_I_Z9002_20161021211900_O_DOR_SA_CAP.bin 973 | Z_RADR_I_Z9002_20161021212500_O_DOR_SA_CAP.bin 974 | Z_RADR_I_Z9002_20161021213100_O_DOR_SA_CAP.bin 975 | Z_RADR_I_Z9002_20161021213600_O_DOR_SA_CAP.bin 976 | Z_RADR_I_Z9002_20161021214200_O_DOR_SA_CAP.bin 977 | Z_RADR_I_Z9002_20161021214800_O_DOR_SA_CAP.bin 978 | Z_RADR_I_Z9002_20161021215300_O_DOR_SA_CAP.bin 979 | Z_RADR_I_Z9002_20161021215900_O_DOR_SA_CAP.bin 980 | Z_RADR_I_Z9002_20161021220500_O_DOR_SA_CAP.bin 981 | Z_RADR_I_Z9002_20161021221100_O_DOR_SA_CAP.bin 982 | Z_RADR_I_Z9002_20161021221600_O_DOR_SA_CAP.bin 983 | Z_RADR_I_Z9002_20161021222200_O_DOR_SA_CAP.bin 984 | Z_RADR_I_Z9002_20161021222800_O_DOR_SA_CAP.bin 985 | Z_RADR_I_Z9002_20161021223300_O_DOR_SA_CAP.bin 986 | Z_RADR_I_Z9002_20161021223900_O_DOR_SA_CAP.bin 987 | Z_RADR_I_Z9002_20161021224500_O_DOR_SA_CAP.bin 988 | Z_RADR_I_Z9002_20161021225100_O_DOR_SA_CAP.bin 989 | Z_RADR_I_Z9002_20161021225600_O_DOR_SA_CAP.bin 990 | Z_RADR_I_Z9002_20161021230200_O_DOR_SA_CAP.bin 991 | Z_RADR_I_Z9002_20161021230800_O_DOR_SA_CAP.bin 992 | Z_RADR_I_Z9002_20161021231300_O_DOR_SA_CAP.bin 993 | Z_RADR_I_Z9002_20161021231900_O_DOR_SA_CAP.bin 994 | Z_RADR_I_Z9002_20161021232500_O_DOR_SA_CAP.bin 995 | Z_RADR_I_Z9002_20161021233100_O_DOR_SA_CAP.bin 996 | Z_RADR_I_Z9002_20161021233600_O_DOR_SA_CAP.bin 997 | Z_RADR_I_Z9002_20161021234200_O_DOR_SA_CAP.bin 998 | Z_RADR_I_Z9002_20161021234800_O_DOR_SA_CAP.bin 999 | Z_RADR_I_Z9002_20161021235300_O_DOR_SA_CAP.bin 1000 | Z_RADR_I_Z9002_20161021235900_O_DOR_SA_CAP.bin 1001 | Z_RADR_I_Z9002_20161022000500_O_DOR_SA_CAP.bin 1002 | Z_RADR_I_Z9002_20161022001100_O_DOR_SA_CAP.bin 1003 | Z_RADR_I_Z9002_20161022001700_O_DOR_SA_CAP.bin 1004 | Z_RADR_I_Z9002_20161022002300_O_DOR_SA_CAP.bin 1005 | Z_RADR_I_Z9002_20161022002800_O_DOR_SA_CAP.bin 1006 | Z_RADR_I_Z9002_20161022003400_O_DOR_SA_CAP.bin 1007 | Z_RADR_I_Z9002_20161022004000_O_DOR_SA_CAP.bin 1008 | Z_RADR_I_Z9002_20161022004500_O_DOR_SA_CAP.bin 1009 | Z_RADR_I_Z9002_20161022005100_O_DOR_SA_CAP.bin 1010 | Z_RADR_I_Z9002_20161022005700_O_DOR_SA_CAP.bin 1011 | Z_RADR_I_Z9002_20161022010300_O_DOR_SA_CAP.bin 1012 | Z_RADR_I_Z9002_20161022010800_O_DOR_SA_CAP.bin 1013 | Z_RADR_I_Z9002_20161022011400_O_DOR_SA_CAP.bin 1014 | Z_RADR_I_Z9002_20161022012000_O_DOR_SA_CAP.bin 1015 | Z_RADR_I_Z9002_20161022012500_O_DOR_SA_CAP.bin 1016 | Z_RADR_I_Z9002_20161022013100_O_DOR_SA_CAP.bin 1017 | Z_RADR_I_Z9002_20161022013700_O_DOR_SA_CAP.bin 1018 | Z_RADR_I_Z9002_20161022014300_O_DOR_SA_CAP.bin 1019 | Z_RADR_I_Z9002_20161022014800_O_DOR_SA_CAP.bin 1020 | Z_RADR_I_Z9002_20161022015400_O_DOR_SA_CAP.bin 1021 | Z_RADR_I_Z9002_20161022020000_O_DOR_SA_CAP.bin 1022 | Z_RADR_I_Z9002_20161022020500_O_DOR_SA_CAP.bin 1023 | Z_RADR_I_Z9002_20161022021100_O_DOR_SA_CAP.bin 1024 | Z_RADR_I_Z9002_20161022021700_O_DOR_SA_CAP.bin 1025 | Z_RADR_I_Z9002_20161022022300_O_DOR_SA_CAP.bin 1026 | Z_RADR_I_Z9002_20161022022800_O_DOR_SA_CAP.bin 1027 | Z_RADR_I_Z9002_20161022023400_O_DOR_SA_CAP.bin 1028 | Z_RADR_I_Z9002_20161022024000_O_DOR_SA_CAP.bin 1029 | Z_RADR_I_Z9002_20161022024500_O_DOR_SA_CAP.bin 1030 | Z_RADR_I_Z9002_20161022025100_O_DOR_SA_CAP.bin 1031 | Z_RADR_I_Z9002_20161022025700_O_DOR_SA_CAP.bin 1032 | Z_RADR_I_Z9002_20161022030200_O_DOR_SA_CAP.bin 1033 | Z_RADR_I_Z9002_20161022030800_O_DOR_SA_CAP.bin 1034 | Z_RADR_I_Z9002_20161022031400_O_DOR_SA_CAP.bin 1035 | Z_RADR_I_Z9002_20161022032000_O_DOR_SA_CAP.bin 1036 | Z_RADR_I_Z9002_20161022032500_O_DOR_SA_CAP.bin 1037 | Z_RADR_I_Z9002_20161022033100_O_DOR_SA_CAP.bin 1038 | Z_RADR_I_Z9002_20161022033700_O_DOR_SA_CAP.bin 1039 | Z_RADR_I_Z9002_20161022034200_O_DOR_SA_CAP.bin 1040 | Z_RADR_I_Z9002_20161022034800_O_DOR_SA_CAP.bin 1041 | Z_RADR_I_Z9002_20161022035400_O_DOR_SA_CAP.bin 1042 | Z_RADR_I_Z9002_20161022040000_O_DOR_SA_CAP.bin 1043 | Z_RADR_I_Z9002_20161022040500_O_DOR_SA_CAP.bin 1044 | Z_RADR_I_Z9002_20161022041100_O_DOR_SA_CAP.bin 1045 | Z_RADR_I_Z9002_20161022041700_O_DOR_SA_CAP.bin 1046 | Z_RADR_I_Z9002_20161022042200_O_DOR_SA_CAP.bin 1047 | Z_RADR_I_Z9002_20161022042800_O_DOR_SA_CAP.bin 1048 | Z_RADR_I_Z9002_20161022043400_O_DOR_SA_CAP.bin 1049 | Z_RADR_I_Z9002_20161022043900_O_DOR_SA_CAP.bin 1050 | Z_RADR_I_Z9002_20161022044500_O_DOR_SA_CAP.bin 1051 | Z_RADR_I_Z9002_20161022045100_O_DOR_SA_CAP.bin 1052 | Z_RADR_I_Z9002_20161022045700_O_DOR_SA_CAP.bin 1053 | Z_RADR_I_Z9002_20161022050200_O_DOR_SA_CAP.bin 1054 | Z_RADR_I_Z9002_20161022050800_O_DOR_SA_CAP.bin 1055 | Z_RADR_I_Z9002_20161022051400_O_DOR_SA_CAP.bin 1056 | Z_RADR_I_Z9002_20161022051900_O_DOR_SA_CAP.bin 1057 | Z_RADR_I_Z9002_20161022052500_O_DOR_SA_CAP.bin 1058 | Z_RADR_I_Z9002_20161022053100_O_DOR_SA_CAP.bin 1059 | Z_RADR_I_Z9002_20161022053700_O_DOR_SA_CAP.bin 1060 | Z_RADR_I_Z9002_20161022054200_O_DOR_SA_CAP.bin 1061 | Z_RADR_I_Z9002_20161022054800_O_DOR_SA_CAP.bin 1062 | Z_RADR_I_Z9002_20161022055400_O_DOR_SA_CAP.bin 1063 | Z_RADR_I_Z9002_20161022055900_O_DOR_SA_CAP.bin 1064 | Z_RADR_I_Z9002_20161022060500_O_DOR_SA_CAP.bin 1065 | Z_RADR_I_Z9002_20161022061100_O_DOR_SA_CAP.bin 1066 | Z_RADR_I_Z9002_20161022061700_O_DOR_SA_CAP.bin 1067 | Z_RADR_I_Z9002_20161022062200_O_DOR_SA_CAP.bin 1068 | Z_RADR_I_Z9002_20161022062800_O_DOR_SA_CAP.bin 1069 | Z_RADR_I_Z9002_20161022063400_O_DOR_SA_CAP.bin 1070 | Z_RADR_I_Z9002_20161022063900_O_DOR_SA_CAP.bin 1071 | Z_RADR_I_Z9002_20161022064500_O_DOR_SA_CAP.bin 1072 | Z_RADR_I_Z9002_20161022065100_O_DOR_SA_CAP.bin 1073 | Z_RADR_I_Z9002_20161022065700_O_DOR_SA_CAP.bin 1074 | Z_RADR_I_Z9002_20161022070200_O_DOR_SA_CAP.bin 1075 | Z_RADR_I_Z9002_20161022070800_O_DOR_SA_CAP.bin 1076 | Z_RADR_I_Z9002_20161022071400_O_DOR_SA_CAP.bin 1077 | Z_RADR_I_Z9002_20161022071900_O_DOR_SA_CAP.bin 1078 | Z_RADR_I_Z9002_20161022072500_O_DOR_SA_CAP.bin 1079 | Z_RADR_I_Z9002_20161022073100_O_DOR_SA_CAP.bin 1080 | Z_RADR_I_Z9002_20161022073700_O_DOR_SA_CAP.bin 1081 | Z_RADR_I_Z9002_20161022074200_O_DOR_SA_CAP.bin 1082 | Z_RADR_I_Z9002_20161022074800_O_DOR_SA_CAP.bin 1083 | Z_RADR_I_Z9002_20161022075400_O_DOR_SA_CAP.bin 1084 | Z_RADR_I_Z9002_20161022075900_O_DOR_SA_CAP.bin 1085 | Z_RADR_I_Z9002_20161022080500_O_DOR_SA_CAP.bin 1086 | Z_RADR_I_Z9002_20161022081100_O_DOR_SA_CAP.bin 1087 | Z_RADR_I_Z9002_20161022081700_O_DOR_SA_CAP.bin 1088 | Z_RADR_I_Z9002_20161022082300_O_DOR_SA_CAP.bin 1089 | Z_RADR_I_Z9002_20161022082800_O_DOR_SA_CAP.bin 1090 | Z_RADR_I_Z9002_20161022083400_O_DOR_SA_CAP.bin 1091 | Z_RADR_I_Z9002_20161022084000_O_DOR_SA_CAP.bin 1092 | Z_RADR_I_Z9002_20161022084600_O_DOR_SA_CAP.bin 1093 | Z_RADR_I_Z9002_20161022085100_O_DOR_SA_CAP.bin 1094 | Z_RADR_I_Z9002_20161022085700_O_DOR_SA_CAP.bin 1095 | Z_RADR_I_Z9002_20161022090300_O_DOR_SA_CAP.bin 1096 | Z_RADR_I_Z9002_20161022090800_O_DOR_SA_CAP.bin 1097 | Z_RADR_I_Z9002_20161022091400_O_DOR_SA_CAP.bin 1098 | Z_RADR_I_Z9002_20161022092000_O_DOR_SA_CAP.bin 1099 | Z_RADR_I_Z9002_20161022092600_O_DOR_SA_CAP.bin 1100 | Z_RADR_I_Z9002_20161022093100_O_DOR_SA_CAP.bin 1101 | Z_RADR_I_Z9002_20161022093700_O_DOR_SA_CAP.bin 1102 | Z_RADR_I_Z9002_20161022094300_O_DOR_SA_CAP.bin 1103 | Z_RADR_I_Z9002_20161022094800_O_DOR_SA_CAP.bin 1104 | Z_RADR_I_Z9002_20161022095400_O_DOR_SA_CAP.bin 1105 | Z_RADR_I_Z9002_20161022100000_O_DOR_SA_CAP.bin 1106 | Z_RADR_I_Z9002_20161022100600_O_DOR_SA_CAP.bin 1107 | Z_RADR_I_Z9002_20161022101100_O_DOR_SA_CAP.bin 1108 | Z_RADR_I_Z9002_20161022101700_O_DOR_SA_CAP.bin 1109 | Z_RADR_I_Z9002_20161022102300_O_DOR_SA_CAP.bin 1110 | Z_RADR_I_Z9002_20161022102800_O_DOR_SA_CAP.bin 1111 | Z_RADR_I_Z9002_20161022103400_O_DOR_SA_CAP.bin 1112 | Z_RADR_I_Z9002_20161022104000_O_DOR_SA_CAP.bin 1113 | Z_RADR_I_Z9002_20161022104600_O_DOR_SA_CAP.bin 1114 | Z_RADR_I_Z9002_20161022105100_O_DOR_SA_CAP.bin 1115 | Z_RADR_I_Z9002_20161022105700_O_DOR_SA_CAP.bin 1116 | Z_RADR_I_Z9002_20161022110300_O_DOR_SA_CAP.bin 1117 | Z_RADR_I_Z9002_20161022110800_O_DOR_SA_CAP.bin 1118 | Z_RADR_I_Z9002_20161022111400_O_DOR_SA_CAP.bin 1119 | Z_RADR_I_Z9002_20161022112000_O_DOR_SA_CAP.bin 1120 | Z_RADR_I_Z9002_20161022112600_O_DOR_SA_CAP.bin 1121 | Z_RADR_I_Z9002_20161022113100_O_DOR_SA_CAP.bin 1122 | Z_RADR_I_Z9002_20161022113700_O_DOR_SA_CAP.bin 1123 | Z_RADR_I_Z9002_20161022114300_O_DOR_SA_CAP.bin 1124 | Z_RADR_I_Z9002_20161022114800_O_DOR_SA_CAP.bin 1125 | Z_RADR_I_Z9002_20161022115400_O_DOR_SA_CAP.bin 1126 | Z_RADR_I_Z9002_20161022120000_O_DOR_SA_CAP.bin 1127 | Z_RADR_I_Z9002_20161022120600_O_DOR_SA_CAP.bin 1128 | Z_RADR_I_Z9002_20161022121100_O_DOR_SA_CAP.bin 1129 | Z_RADR_I_Z9002_20161022121700_O_DOR_SA_CAP.bin 1130 | Z_RADR_I_Z9002_20161022122300_O_DOR_SA_CAP.bin 1131 | Z_RADR_I_Z9002_20161022122800_O_DOR_SA_CAP.bin 1132 | Z_RADR_I_Z9002_20161022123400_O_DOR_SA_CAP.bin 1133 | Z_RADR_I_Z9002_20161022124000_O_DOR_SA_CAP.bin 1134 | Z_RADR_I_Z9002_20161022124600_O_DOR_SA_CAP.bin 1135 | Z_RADR_I_Z9002_20161022125100_O_DOR_SA_CAP.bin 1136 | Z_RADR_I_Z9002_20161022125700_O_DOR_SA_CAP.bin 1137 | Z_RADR_I_Z9002_20161022130300_O_DOR_SA_CAP.bin 1138 | Z_RADR_I_Z9002_20161022130800_O_DOR_SA_CAP.bin 1139 | Z_RADR_I_Z9002_20161022131400_O_DOR_SA_CAP.bin 1140 | Z_RADR_I_Z9002_20161022132000_O_DOR_SA_CAP.bin 1141 | Z_RADR_I_Z9002_20161022132500_O_DOR_SA_CAP.bin 1142 | Z_RADR_I_Z9002_20161022133100_O_DOR_SA_CAP.bin 1143 | Z_RADR_I_Z9002_20161022133700_O_DOR_SA_CAP.bin 1144 | Z_RADR_I_Z9002_20161022134300_O_DOR_SA_CAP.bin 1145 | Z_RADR_I_Z9002_20161022134800_O_DOR_SA_CAP.bin 1146 | Z_RADR_I_Z9002_20161022135400_O_DOR_SA_CAP.bin 1147 | Z_RADR_I_Z9002_20161022140000_O_DOR_SA_CAP.bin 1148 | Z_RADR_I_Z9002_20161022140500_O_DOR_SA_CAP.bin 1149 | Z_RADR_I_Z9002_20161022141100_O_DOR_SA_CAP.bin 1150 | Z_RADR_I_Z9002_20161022141700_O_DOR_SA_CAP.bin 1151 | Z_RADR_I_Z9002_20161022142300_O_DOR_SA_CAP.bin 1152 | Z_RADR_I_Z9002_20161022142800_O_DOR_SA_CAP.bin 1153 | Z_RADR_I_Z9002_20161022143400_O_DOR_SA_CAP.bin 1154 | Z_RADR_I_Z9002_20161022144000_O_DOR_SA_CAP.bin 1155 | Z_RADR_I_Z9002_20161022144500_O_DOR_SA_CAP.bin 1156 | Z_RADR_I_Z9002_20161022145100_O_DOR_SA_CAP.bin 1157 | Z_RADR_I_Z9002_20161022145700_O_DOR_SA_CAP.bin 1158 | Z_RADR_I_Z9002_20161022150300_O_DOR_SA_CAP.bin 1159 | Z_RADR_I_Z9002_20161022150800_O_DOR_SA_CAP.bin 1160 | Z_RADR_I_Z9002_20161022151400_O_DOR_SA_CAP.bin 1161 | Z_RADR_I_Z9002_20161022152000_O_DOR_SA_CAP.bin 1162 | Z_RADR_I_Z9002_20161022152500_O_DOR_SA_CAP.bin 1163 | Z_RADR_I_Z9002_20161022153100_O_DOR_SA_CAP.bin 1164 | Z_RADR_I_Z9002_20161022153700_O_DOR_SA_CAP.bin 1165 | Z_RADR_I_Z9002_20161022154200_O_DOR_SA_CAP.bin 1166 | Z_RADR_I_Z9002_20161022154800_O_DOR_SA_CAP.bin 1167 | Z_RADR_I_Z9002_20161022155400_O_DOR_SA_CAP.bin 1168 | Z_RADR_I_Z9002_20161022160000_O_DOR_SA_CAP.bin 1169 | Z_RADR_I_Z9002_20161022160500_O_DOR_SA_CAP.bin 1170 | Z_RADR_I_Z9002_20161022161100_O_DOR_SA_CAP.bin 1171 | Z_RADR_I_Z9002_20161022161700_O_DOR_SA_CAP.bin 1172 | Z_RADR_I_Z9002_20161022162300_O_DOR_SA_CAP.bin 1173 | Z_RADR_I_Z9002_20161022162900_O_DOR_SA_CAP.bin 1174 | Z_RADR_I_Z9002_20161022163400_O_DOR_SA_CAP.bin 1175 | Z_RADR_I_Z9002_20161022164000_O_DOR_SA_CAP.bin 1176 | Z_RADR_I_Z9002_20161022164600_O_DOR_SA_CAP.bin 1177 | Z_RADR_I_Z9002_20161022165200_O_DOR_SA_CAP.bin 1178 | Z_RADR_I_Z9002_20161022165700_O_DOR_SA_CAP.bin 1179 | Z_RADR_I_Z9002_20161022170300_O_DOR_SA_CAP.bin 1180 | Z_RADR_I_Z9002_20161022170900_O_DOR_SA_CAP.bin 1181 | Z_RADR_I_Z9002_20161022171400_O_DOR_SA_CAP.bin 1182 | Z_RADR_I_Z9002_20161022172000_O_DOR_SA_CAP.bin 1183 | Z_RADR_I_Z9002_20161022172600_O_DOR_SA_CAP.bin 1184 | Z_RADR_I_Z9002_20161022173200_O_DOR_SA_CAP.bin 1185 | Z_RADR_I_Z9002_20161022173700_O_DOR_SA_CAP.bin 1186 | Z_RADR_I_Z9002_20161022174300_O_DOR_SA_CAP.bin 1187 | Z_RADR_I_Z9002_20161022174900_O_DOR_SA_CAP.bin 1188 | Z_RADR_I_Z9002_20161022175400_O_DOR_SA_CAP.bin 1189 | Z_RADR_I_Z9002_20161022180000_O_DOR_SA_CAP.bin 1190 | Z_RADR_I_Z9002_20161022180600_O_DOR_SA_CAP.bin 1191 | Z_RADR_I_Z9002_20161022181200_O_DOR_SA_CAP.bin 1192 | Z_RADR_I_Z9002_20161022181700_O_DOR_SA_CAP.bin 1193 | Z_RADR_I_Z9002_20161022182300_O_DOR_SA_CAP.bin 1194 | Z_RADR_I_Z9002_20161022182900_O_DOR_SA_CAP.bin 1195 | Z_RADR_I_Z9002_20161022183400_O_DOR_SA_CAP.bin 1196 | Z_RADR_I_Z9002_20161022184000_O_DOR_SA_CAP.bin 1197 | Z_RADR_I_Z9002_20161022184600_O_DOR_SA_CAP.bin 1198 | Z_RADR_I_Z9002_20161022185100_O_DOR_SA_CAP.bin 1199 | Z_RADR_I_Z9002_20161022185700_O_DOR_SA_CAP.bin 1200 | Z_RADR_I_Z9002_20161022190300_O_DOR_SA_CAP.bin 1201 | Z_RADR_I_Z9002_20161022190900_O_DOR_SA_CAP.bin 1202 | Z_RADR_I_Z9002_20161022191400_O_DOR_SA_CAP.bin 1203 | Z_RADR_I_Z9002_20161022192000_O_DOR_SA_CAP.bin 1204 | Z_RADR_I_Z9002_20161022192600_O_DOR_SA_CAP.bin 1205 | Z_RADR_I_Z9002_20161022193100_O_DOR_SA_CAP.bin 1206 | Z_RADR_I_Z9002_20161022193700_O_DOR_SA_CAP.bin 1207 | Z_RADR_I_Z9002_20161022194300_O_DOR_SA_CAP.bin 1208 | Z_RADR_I_Z9002_20161022194900_O_DOR_SA_CAP.bin 1209 | Z_RADR_I_Z9002_20161022195400_O_DOR_SA_CAP.bin 1210 | Z_RADR_I_Z9002_20161022200000_O_DOR_SA_CAP.bin 1211 | Z_RADR_I_Z9002_20161022200600_O_DOR_SA_CAP.bin 1212 | Z_RADR_I_Z9002_20161022201100_O_DOR_SA_CAP.bin 1213 | Z_RADR_I_Z9002_20161022201700_O_DOR_SA_CAP.bin 1214 | Z_RADR_I_Z9002_20161022202300_O_DOR_SA_CAP.bin 1215 | Z_RADR_I_Z9002_20161022202900_O_DOR_SA_CAP.bin 1216 | Z_RADR_I_Z9002_20161022203400_O_DOR_SA_CAP.bin 1217 | Z_RADR_I_Z9002_20161022204000_O_DOR_SA_CAP.bin 1218 | Z_RADR_I_Z9002_20161022204600_O_DOR_SA_CAP.bin 1219 | Z_RADR_I_Z9002_20161022205100_O_DOR_SA_CAP.bin 1220 | Z_RADR_I_Z9002_20161022205700_O_DOR_SA_CAP.bin 1221 | Z_RADR_I_Z9002_20161022210300_O_DOR_SA_CAP.bin 1222 | Z_RADR_I_Z9002_20161022210900_O_DOR_SA_CAP.bin 1223 | Z_RADR_I_Z9002_20161022211400_O_DOR_SA_CAP.bin 1224 | Z_RADR_I_Z9002_20161022212000_O_DOR_SA_CAP.bin 1225 | Z_RADR_I_Z9002_20161022212600_O_DOR_SA_CAP.bin 1226 | Z_RADR_I_Z9002_20161022213100_O_DOR_SA_CAP.bin 1227 | Z_RADR_I_Z9002_20161022213700_O_DOR_SA_CAP.bin 1228 | Z_RADR_I_Z9002_20161022214300_O_DOR_SA_CAP.bin 1229 | Z_RADR_I_Z9002_20161022214800_O_DOR_SA_CAP.bin 1230 | Z_RADR_I_Z9002_20161022215400_O_DOR_SA_CAP.bin 1231 | Z_RADR_I_Z9002_20161022220000_O_DOR_SA_CAP.bin 1232 | Z_RADR_I_Z9002_20161022220600_O_DOR_SA_CAP.bin 1233 | Z_RADR_I_Z9002_20161022221100_O_DOR_SA_CAP.bin 1234 | Z_RADR_I_Z9002_20161022221700_O_DOR_SA_CAP.bin 1235 | Z_RADR_I_Z9002_20161022222300_O_DOR_SA_CAP.bin 1236 | Z_RADR_I_Z9002_20161022222800_O_DOR_SA_CAP.bin 1237 | Z_RADR_I_Z9002_20161022223400_O_DOR_SA_CAP.bin 1238 | Z_RADR_I_Z9002_20161022224000_O_DOR_SA_CAP.bin 1239 | Z_RADR_I_Z9002_20161022224600_O_DOR_SA_CAP.bin 1240 | Z_RADR_I_Z9002_20161022225100_O_DOR_SA_CAP.bin 1241 | Z_RADR_I_Z9002_20161022225700_O_DOR_SA_CAP.bin 1242 | Z_RADR_I_Z9002_20161022230300_O_DOR_SA_CAP.bin 1243 | Z_RADR_I_Z9002_20161022230800_O_DOR_SA_CAP.bin 1244 | Z_RADR_I_Z9002_20161022231400_O_DOR_SA_CAP.bin 1245 | Z_RADR_I_Z9002_20161022232000_O_DOR_SA_CAP.bin 1246 | Z_RADR_I_Z9002_20161022232500_O_DOR_SA_CAP.bin 1247 | Z_RADR_I_Z9002_20161022233100_O_DOR_SA_CAP.bin 1248 | Z_RADR_I_Z9002_20161022233700_O_DOR_SA_CAP.bin 1249 | Z_RADR_I_Z9002_20161022234300_O_DOR_SA_CAP.bin 1250 | Z_RADR_I_Z9002_20161022234800_O_DOR_SA_CAP.bin 1251 | Z_RADR_I_Z9002_20161022235400_O_DOR_SA_CAP.bin 1252 | --------------------------------------------------------------------------------