Skip to content

data.h5py.H5CParser

Class · Context · Source

dset = mdnc.data.h5py.H5CParser(
    file_name, keywords_sequence, keywords_single, batch_size=32,
    sequence_size=5, sequence_position=-1, sequence_padding='same',
    shuffle=True, shuffle_seed=1000, preprocfunc=None,
    num_workers=4, num_buffer=10
)

This class allows users to feed one .h5 file, and parse it by mdnc.data.sequence.MPSequence. The realization could be described as:

This parser is the upgraded version of mdnc.data.h5py.H5GParser, it is specially designed for parsing data to LSTM/ConvLSTM. A sequence dimension would be inserted between batches and channels. In each batch, the sequence is continuously extracted in the order of the batches. During each epoch, a sliding window would iterate the first axis (samples). The number of batches would be the same as using mdnc.data.h5py.H5GParser. For each variable specified by keywords_sequence, each sample in the mini-batch is a sequence.

This parser could also read the dataset converted by mdnc.data.h5py.H5SeqConverter. The workflow is shown in the following figure:

Arguments

Requries

Argument Type Description
file_name str The path of the .h5 file (could be without postfix).
keywords_sequence (str, ) The keyword of sequence data. The keywords in this list would be parsed as (B, S, C1, C2, ...), where B and S are the sample number and sequence length (given by the argument sequence_size) respectively. It should be a list of keywords (or a single keyword).
keyword_single (str, ) The keyword of single values. The keywords in this list would be parsed as (B, C1, C2, ...), where B is the sample number. It should be a list of keywords (or a single keyword).
batch_size int Number of samples in each mini-batch.
sequence_size int The size of each sequence. It represents S of (B, S, C1, C2, ...).
sequence_position int The aligned position between the single values and the sequence values. It should be in the range of >= 0 and < sequence_size.
sequence_padding int The padding method for each epoch, it will influence the first or the final samples in the dataset. Could be 'same', 'zero' or 'none'. If set None, the number of batches of each epoch would be a little bit smaller than the actual number.
shuffle bool If enabled, shuffle the data set at the beginning of each epoch.
shuffle_seed int The seed for random shuffling.
preprocfunc object This function would be added to the produced data so that it could serve as a pre-processing tool. Note that this tool would process the batches produced by the parser. The details about this argument would be shown in the following tips.
num_workers int The number of parallel workers.
num_buffer int The buffer size of the data pool, it means the maximal number of mini-batches stored in the memory.
Tip

At least one keyword requires to be given in keywords_sequence or keyword_single. In some cases, we need to use both kinds of keywords. For example, the input could be a sequence, and the label may be a scalar.

Tip

The minimal requirement for the argument preprocfunc is to be a function, or implemented with the __call__() method. This function accepts all input mini-batch variables formatted as np.ndarray, and returns the pre-processed results. The returned varaible number could be different from the input variable number. In some cases, you could use the provided pre-processors in the mdnc.data.preprocs module. The processors in these module support our Broadcasting Pre- and Post- Processor Protocol. For example:

Example

1
2
3
4
5
6
7
import mdnc

def preprocfunc(x1, x2):
    return x1 + x2

mdnc.data.h5py.H5CParser(..., keywords_sequence=['x_1', 'x_2'],
                         preprocfunc=preprocfunc)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
import mdnc

class PreprocWithArgs:
    def __init__(self, a):
        self.a = a

    def __call__(self, x1, x2):
        return x1, self.a * x2

mdnc.data.h5py.H5CParser(..., keywords_sequence=['x_1', 'x_2'],
                         preprocfunc=PreprocWithArgs(a=0.1))

1
2
3
4
import mdnc

mdnc.data.h5py.H5CParser(..., keywords=['x_1', 'x_2'],
                         preprocfunc=mdnc.data.preprocs.ProcScaler())

Warning

The argument preprocfunc requires to be a picklable object. Therefore, a lambda function or a function implemented inside if __name__ == '__main__' is not allowed in this case.

Methods

check_dsets

sze = dset.check_dsets(file_path, keywords)

Check the size of h5py.Dataset and validate all datasets. A valid group of datasets requires each h5py.Dataset shares the same length (sample number). If success, would return the size of the datasets. This method is invoked during the initialization, and do not requires users to call explicitly.

Requries

Argument Type Description
file_path str The path of the HDF5 dataset to be validated.
keywords (str, ) The keywords to be validated. Each keyword should point to or redict to an h5py.Dataset.

Returns

Argument Description
sze A int, the size of all datasets.

get_attrs

attrs = dset.get_attrs(keyword, *args, attr_names=None)

Get the attributes by the keyword.

Requries

Argument Type Description
keyword str The keyword of the to a h5py.Dataset in the to-be-loaded file.
attr_names (str, ) A sequence of required attribute names.
*args other attribute names, would be attached to the argument attr_names by list.extend().

Returns

Argument Description
attrs A list of the required attribute values.

get_file

f = dset.get_file(enable_write=False)

Get a file object of the to-be-loaded file.

Requries

Argument Type Description
enable_write bool If enabled, would use the a mode to open the file. Otherwise, use the r mode.

Returns

Argument Description
f The h5py.File object of the to-be-loaded file.

start

dset.start(compat=None)

Start the process pool. This method is implemented by mdnc.data.sequence.MPSequence. It supports context management.

Running start() or start_test() would interrupt the started sequence.

Requries

Argument Type Description
compat bool Whether to fall back to multi-threading for the sequence out-type converter. If set None, the decision would be made by checking os.name. The compatible mode requires to be enabled on Windows.
Tip

This method supports context management. Using the context is recommended. Here we show two examples:

1
2
3
4
dset.start()
for ... in dset:
    ...
dset.finish()

1
2
3
with dset.start() as ds:
    for ... in ds:
        ...
Danger

The cuda.Tensor could not be put into the queue on Windows (but on Linux we could), see

https://pytorch.org/docs/stable/notes/windows.html#cuda-ipc-operations

To solve this problem, we need to fall back to multi-threading for the sequence out-type converter on Windows.

Warning

Even if you set shuffle=False, due to the mechanism of the parallelization, the sample order during the iteration may still get a little bit shuffled. To ensure your sample order not changed, please use shuffle=False during the initialization and use start_test() instead.

start_test

dset.start_test(test_mode='default')

Start the test mode. In the test mode, the process pool would not be open. All operations would be finished in the main thread. However, the random indices are still generated with the same seed of the parallel dset.start() mode.

Running start() or start_test() would interrupt the started sequence.

Requries

Argument Type Description
test_mode str Could be 'default', 'cpu', or 'numpy'.
  • 'default': the output would be converted as start() mode.
  • 'cpu': even set 'cuda' as output type, the testing output would be still not converted to GPU.
  • 'numpy': would ignore all out_type configurations and return the original output. This output is still pre-processed.
Tip

This method also supports context management. See start() to check how to use it.

finish

dset.finish()

Finish the process pool. The compatible mode would be auto detected by the previous start().

Properties

len(), batch_num

len(dset)
dset.batch_num

The length of the dataset. It is the number of mini-batches, also the number of iterations for each epoch.

iter()

for x1, x2, ... in dset:
    ...

The iterator. Recommend to use it inside the context. The unpacked variables x1, x2 ... are ordered according to the given argument keywords during the initialization.

size

dset.size

The size of the dataset. It contains the total number of samples for each epoch.

batch_size

dset.batch_size

The size of each batch. This value is given by the argument batch_size during the initialization. The last size of the batch may be smaller than this value.

sequence_size

dset.sequence_size

The length of each sequence. This value is given by the argument sequence_size during the initialization.

sequence_position

dset.sequence_position

The alignment between keywords_sequence and keyword_single. This value is given by the argument sequence_position during the initialization.

sequence_padding

dset.sequence_position

The padding method of each sequence. This value is given by the argument sequence_padding during the initialization.

preproc

dset.preproc

The argument preprocfunc during the initialziation. This property helps users to invoke the preprocessor manually.

Examples

Example 1
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import os
import mdnc

root_folder = 'alpha-test'
os.makedirs(root_folder, exist_ok=True)

if __name__ == '__main__':
    # Prepare the datasets.
    set_list_file = os.path.join(root_folder, 'web-data')
    mdnc.data.webtools.DataChecker.init_set_list(set_list_file)
    dc = mdnc.data.webtools.DataChecker(root=root_folder, set_list_file=set_list_file, token='', verbose=False)
    dc.add_query_file('test_data_h5cparser.h5')
    dc.query()

    # Perform test.
    dset = mdnc.data.h5py.H5CParser(os.path.join(root_folder, 'test_data_h5cparser'), keywords_sequence=['key1', 'key3'], keywords_single=['key2'],
                                    batch_size=1, sequence_size=5, sequence_position=0, sequence_padding='same',
                                    shuffle=False, preprocfunc=None, num_workers=1, num_buffer=1)

    with dset.start() as p:
        for i, data in enumerate(p):
            d1, d2, d3 = data
            print('data.h5py:', i, d1[:, :], d2.shape, d3)

data.webtools: All required datasets are available.
data.h5py: 0 tensor([[0., 1., 2., 3., 4.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([1.], device='cuda:0')
data.h5py: 1 tensor([[1., 2., 3., 4., 5.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([2.], device='cuda:0')
data.h5py: 2 tensor([[2., 3., 4., 5., 6.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([3.], device='cuda:0')
data.h5py: 3 tensor([[3., 4., 5., 6., 7.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([4.], device='cuda:0')
data.h5py: 4 tensor([[4., 5., 6., 7., 8.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([5.], device='cuda:0')
data.h5py: 5 tensor([[5., 6., 7., 8., 9.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([6.], device='cuda:0')
data.h5py: 6 tensor([[ 6.,  7.,  8.,  9., 10.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([7.], device='cuda:0')
data.h5py: 7 tensor([[ 7.,  8.,  9., 10., 11.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([8.], device='cuda:0')
data.h5py: 8 tensor([[ 8.,  9., 10., 11., 12.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([9.], device='cuda:0')
data.h5py: 9 tensor([[ 9., 10., 11., 12., 13.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([10.], device='cuda:0')
data.h5py: 10 tensor([[10., 11., 12., 13., 14.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([11.], device='cuda:0')
data.h5py: 11 tensor([[11., 12., 13., 14., 15.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([12.], device='cuda:0')
data.h5py: 12 tensor([[12., 13., 14., 15., 16.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([13.], device='cuda:0')
data.h5py: 13 tensor([[13., 14., 15., 16., 17.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([14.], device='cuda:0')
data.h5py: 14 tensor([[14., 15., 16., 17., 18.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([15.], device='cuda:0')
data.h5py: 15 tensor([[15., 16., 17., 18., 19.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([16.], device='cuda:0')
data.h5py: 16 tensor([[16., 17., 18., 19., 20.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([17.], device='cuda:0')
data.h5py: 17 tensor([[17., 18., 19., 20., 21.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([18.], device='cuda:0')
data.h5py: 18 tensor([[18., 19., 20., 21., 22.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([19.], device='cuda:0')
data.h5py: 19 tensor([[19., 20., 21., 22., 23.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([20.], device='cuda:0')
data.h5py: 20 tensor([[20., 21., 22., 23., 24.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([21.], device='cuda:0')
data.h5py: 21 tensor([[21., 22., 23., 24., 25.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([22.], device='cuda:0')
data.h5py: 22 tensor([[22., 23., 24., 25., 26.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([23.], device='cuda:0')
data.h5py: 23 tensor([[23., 24., 25., 26., 27.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([24.], device='cuda:0')
data.h5py: 24 tensor([[24., 25., 26., 27., 28.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([25.], device='cuda:0')
data.h5py: 25 tensor([[25., 26., 27., 28., 29.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([26.], device='cuda:0')
data.h5py: 26 tensor([[26., 27., 28., 29., 30.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([27.], device='cuda:0')
data.h5py: 27 tensor([[27., 28., 29., 30., 31.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([28.], device='cuda:0')
data.h5py: 28 tensor([[28., 29., 30., 31., 32.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([29.], device='cuda:0')
data.h5py: 29 tensor([[29., 30., 31., 32., 33.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([30.], device='cuda:0')
data.h5py: 30 tensor([[30., 31., 32., 33., 34.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([31.], device='cuda:0')
data.h5py: 31 tensor([[31., 32., 33., 34., 35.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([32.], device='cuda:0')
data.h5py: 32 tensor([[32., 33., 34., 35., 36.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([33.], device='cuda:0')
data.h5py: 33 tensor([[33., 34., 35., 36., 37.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([34.], device='cuda:0')
data.h5py: 34 tensor([[34., 35., 36., 37., 38.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([35.], device='cuda:0')
data.h5py: 35 tensor([[35., 36., 37., 38., 39.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([36.], device='cuda:0')
data.h5py: 36 tensor([[36., 37., 38., 39., 40.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([37.], device='cuda:0')
data.h5py: 37 tensor([[37., 38., 39., 40., 41.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([38.], device='cuda:0')
data.h5py: 38 tensor([[38., 39., 40., 41., 42.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([39.], device='cuda:0')
data.h5py: 39 tensor([[39., 40., 41., 42., 43.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([40.], device='cuda:0')
data.h5py: 40 tensor([[40., 41., 42., 43., 44.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([41.], device='cuda:0')
data.h5py: 41 tensor([[41., 42., 43., 44., 45.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([42.], device='cuda:0')
data.h5py: 42 tensor([[42., 43., 44., 45., 46.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([43.], device='cuda:0')
data.h5py: 43 tensor([[43., 44., 45., 46., 47.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([44.], device='cuda:0')
data.h5py: 44 tensor([[44., 45., 46., 47., 48.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([45.], device='cuda:0')
data.h5py: 45 tensor([[45., 46., 47., 48., 49.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([46.], device='cuda:0')
data.h5py: 46 tensor([[46., 47., 48., 49., 50.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([47.], device='cuda:0')
data.h5py: 47 tensor([[47., 48., 49., 50., 51.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([48.], device='cuda:0')
data.h5py: 48 tensor([[48., 49., 50., 51., 52.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([49.], device='cuda:0')
data.h5py: 49 tensor([[49., 50., 51., 52., 53.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([50.], device='cuda:0')
data.h5py: 50 tensor([[50., 51., 52., 53., 54.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([51.], device='cuda:0')
data.h5py: 51 tensor([[51., 52., 53., 54., 55.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([52.], device='cuda:0')
data.h5py: 52 tensor([[52., 53., 54., 55., 56.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([53.], device='cuda:0')
data.h5py: 53 tensor([[53., 54., 55., 56., 57.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([54.], device='cuda:0')
data.h5py: 54 tensor([[54., 55., 56., 57., 58.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([55.], device='cuda:0')
data.h5py: 55 tensor([[55., 56., 57., 58., 59.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([56.], device='cuda:0')
data.h5py: 56 tensor([[56., 57., 58., 59., 60.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([57.], device='cuda:0')
data.h5py: 57 tensor([[57., 58., 59., 60., 61.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([58.], device='cuda:0')
data.h5py: 58 tensor([[58., 59., 60., 61., 62.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([59.], device='cuda:0')
data.h5py: 59 tensor([[59., 60., 61., 62., 63.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([60.], device='cuda:0')
data.h5py: 60 tensor([[60., 61., 62., 63., 64.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([61.], device='cuda:0')
data.h5py: 61 tensor([[61., 62., 63., 64., 65.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([62.], device='cuda:0')
data.h5py: 62 tensor([[62., 63., 64., 65., 66.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([63.], device='cuda:0')
data.h5py: 63 tensor([[63., 64., 65., 66., 67.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([64.], device='cuda:0')
data.h5py: 64 tensor([[64., 65., 66., 67., 68.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([65.], device='cuda:0')
data.h5py: 65 tensor([[65., 66., 67., 68., 69.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([66.], device='cuda:0')
data.h5py: 66 tensor([[66., 67., 68., 69., 70.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([67.], device='cuda:0')
data.h5py: 67 tensor([[67., 68., 69., 70., 71.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([68.], device='cuda:0')
data.h5py: 68 tensor([[68., 69., 70., 71., 72.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([69.], device='cuda:0')
data.h5py: 69 tensor([[69., 70., 71., 72., 73.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([70.], device='cuda:0')
data.h5py: 70 tensor([[70., 71., 72., 73., 74.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([71.], device='cuda:0')
data.h5py: 71 tensor([[71., 72., 73., 74., 75.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([72.], device='cuda:0')
data.h5py: 72 tensor([[72., 73., 74., 75., 76.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([73.], device='cuda:0')
data.h5py: 73 tensor([[73., 74., 75., 76., 77.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([74.], device='cuda:0')
data.h5py: 74 tensor([[74., 75., 76., 77., 78.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([75.], device='cuda:0')
data.h5py: 75 tensor([[75., 76., 77., 78., 79.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([76.], device='cuda:0')
data.h5py: 76 tensor([[76., 77., 78., 79., 80.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([77.], device='cuda:0')
data.h5py: 77 tensor([[77., 78., 79., 80., 81.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([78.], device='cuda:0')
data.h5py: 78 tensor([[78., 79., 80., 81., 82.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([79.], device='cuda:0')
data.h5py: 79 tensor([[79., 80., 81., 82., 83.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([80.], device='cuda:0')
data.h5py: 80 tensor([[80., 81., 82., 83., 84.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([81.], device='cuda:0')
data.h5py: 81 tensor([[81., 82., 83., 84., 85.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([82.], device='cuda:0')
data.h5py: 82 tensor([[82., 83., 84., 85., 86.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([83.], device='cuda:0')
data.h5py: 83 tensor([[83., 84., 85., 86., 87.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([84.], device='cuda:0')
data.h5py: 84 tensor([[84., 85., 86., 87., 88.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([85.], device='cuda:0')
data.h5py: 85 tensor([[85., 86., 87., 88., 89.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([86.], device='cuda:0')
data.h5py: 86 tensor([[86., 87., 88., 89., 90.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([87.], device='cuda:0')
data.h5py: 87 tensor([[87., 88., 89., 90., 91.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([88.], device='cuda:0')
data.h5py: 88 tensor([[88., 89., 90., 91., 92.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([89.], device='cuda:0')
data.h5py: 89 tensor([[89., 90., 91., 92., 93.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([90.], device='cuda:0')
data.h5py: 90 tensor([[90., 91., 92., 93., 94.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([91.], device='cuda:0')
data.h5py: 91 tensor([[91., 92., 93., 94., 95.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([92.], device='cuda:0')
data.h5py: 92 tensor([[92., 93., 94., 95., 96.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([93.], device='cuda:0')
data.h5py: 93 tensor([[93., 94., 95., 96., 97.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([94.], device='cuda:0')
data.h5py: 94 tensor([[94., 95., 96., 97., 98.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([95.], device='cuda:0')
data.h5py: 95 tensor([[95., 96., 97., 98., 99.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([96.], device='cuda:0')
data.h5py: 96 tensor([[ 96.,  97.,  98.,  99., 100.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([97.], device='cuda:0')
data.h5py: 97 tensor([[ 97.,  98.,  99., 100., 101.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([98.], device='cuda:0')
data.h5py: 98 tensor([[ 98.,  99., 100., 101., 102.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([99.], device='cuda:0')
data.h5py: 99 tensor([[ 99., 100., 101., 102., 103.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([100.], device='cuda:0')
data.h5py: 100 tensor([[100., 101., 102., 103., 104.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([101.], device='cuda:0')
data.h5py: 101 tensor([[101., 102., 103., 104., 105.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([102.], device='cuda:0')
data.h5py: 102 tensor([[102., 103., 104., 105., 106.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([103.], device='cuda:0')
data.h5py: 103 tensor([[103., 104., 105., 106., 107.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([104.], device='cuda:0')
data.h5py: 104 tensor([[104., 105., 106., 107., 108.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([105.], device='cuda:0')
data.h5py: 105 tensor([[105., 106., 107., 108., 109.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([106.], device='cuda:0')
data.h5py: 106 tensor([[106., 107., 108., 109., 110.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([107.], device='cuda:0')
data.h5py: 107 tensor([[107., 108., 109., 110., 111.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([108.], device='cuda:0')
data.h5py: 108 tensor([[108., 109., 110., 111., 112.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([109.], device='cuda:0')
data.h5py: 109 tensor([[109., 110., 111., 112., 113.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([110.], device='cuda:0')
data.h5py: 110 tensor([[110., 111., 112., 113., 114.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([111.], device='cuda:0')
data.h5py: 111 tensor([[111., 112., 113., 114., 115.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([112.], device='cuda:0')
data.h5py: 112 tensor([[112., 113., 114., 115., 116.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([113.], device='cuda:0')
data.h5py: 113 tensor([[113., 114., 115., 116., 117.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([114.], device='cuda:0')
data.h5py: 114 tensor([[114., 115., 116., 117., 118.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([115.], device='cuda:0')
data.h5py: 115 tensor([[115., 116., 117., 118., 119.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([116.], device='cuda:0')
data.h5py: 116 tensor([[116., 117., 118., 119., 120.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([117.], device='cuda:0')
data.h5py: 117 tensor([[117., 118., 119., 120., 121.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([118.], device='cuda:0')
data.h5py: 118 tensor([[118., 119., 120., 121., 122.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([119.], device='cuda:0')
data.h5py: 119 tensor([[119., 120., 121., 122., 123.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([120.], device='cuda:0')
data.h5py: 120 tensor([[120., 121., 122., 123., 124.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([121.], device='cuda:0')
data.h5py: 121 tensor([[121., 122., 123., 124., 125.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([122.], device='cuda:0')
data.h5py: 122 tensor([[122., 123., 124., 125., 126.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([123.], device='cuda:0')
data.h5py: 123 tensor([[123., 124., 125., 126., 127.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([124.], device='cuda:0')
data.h5py: 124 tensor([[124., 125., 126., 127., 128.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([125.], device='cuda:0')
data.h5py: 125 tensor([[125., 126., 127., 128., 129.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([126.], device='cuda:0')
data.h5py: 126 tensor([[126., 127., 128., 129., 130.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([127.], device='cuda:0')
data.h5py: 127 tensor([[127., 128., 129., 130., 131.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([128.], device='cuda:0')
data.h5py: 128 tensor([[128., 129., 130., 131., 132.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([129.], device='cuda:0')
data.h5py: 129 tensor([[129., 130., 131., 132., 133.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([130.], device='cuda:0')
data.h5py: 130 tensor([[130., 131., 132., 133., 134.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([131.], device='cuda:0')
data.h5py: 131 tensor([[131., 132., 133., 134., 135.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([132.], device='cuda:0')
data.h5py: 132 tensor([[132., 133., 134., 135., 136.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([133.], device='cuda:0')
data.h5py: 133 tensor([[133., 134., 135., 136., 137.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([134.], device='cuda:0')
data.h5py: 134 tensor([[134., 135., 136., 137., 138.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([135.], device='cuda:0')
data.h5py: 135 tensor([[135., 136., 137., 138., 139.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([136.], device='cuda:0')
data.h5py: 136 tensor([[136., 137., 138., 139., 140.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([137.], device='cuda:0')
data.h5py: 137 tensor([[137., 138., 139., 140., 141.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([138.], device='cuda:0')
data.h5py: 138 tensor([[138., 139., 140., 141., 142.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([139.], device='cuda:0')
data.h5py: 139 tensor([[139., 140., 141., 142., 143.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([140.], device='cuda:0')
data.h5py: 140 tensor([[140., 141., 142., 143., 144.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([141.], device='cuda:0')
data.h5py: 141 tensor([[141., 142., 143., 144., 145.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([142.], device='cuda:0')
data.h5py: 142 tensor([[142., 143., 144., 145., 146.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([143.], device='cuda:0')
data.h5py: 143 tensor([[143., 144., 145., 146., 147.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([144.], device='cuda:0')
data.h5py: 144 tensor([[144., 145., 146., 147., 148.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([145.], device='cuda:0')
data.h5py: 145 tensor([[145., 146., 147., 148., 149.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([146.], device='cuda:0')
data.h5py: 146 tensor([[146., 147., 148., 149., 150.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([147.], device='cuda:0')
data.h5py: 147 tensor([[147., 148., 149., 150., 151.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([148.], device='cuda:0')
data.h5py: 148 tensor([[148., 149., 150., 151., 152.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([149.], device='cuda:0')
data.h5py: 149 tensor([[149., 150., 151., 152., 153.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([150.], device='cuda:0')
data.h5py: 150 tensor([[150., 151., 152., 153., 154.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([151.], device='cuda:0')
data.h5py: 151 tensor([[151., 152., 153., 154., 155.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([152.], device='cuda:0')
data.h5py: 152 tensor([[152., 153., 154., 155., 156.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([153.], device='cuda:0')
data.h5py: 153 tensor([[153., 154., 155., 156., 157.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([154.], device='cuda:0')
data.h5py: 154 tensor([[154., 155., 156., 157., 158.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([155.], device='cuda:0')
data.h5py: 155 tensor([[155., 156., 157., 158., 159.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([156.], device='cuda:0')
data.h5py: 156 tensor([[156., 157., 158., 159., 160.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([157.], device='cuda:0')
data.h5py: 157 tensor([[157., 158., 159., 160., 161.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([158.], device='cuda:0')
data.h5py: 158 tensor([[158., 159., 160., 161., 162.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([159.], device='cuda:0')
data.h5py: 159 tensor([[159., 160., 161., 162., 163.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([160.], device='cuda:0')
data.h5py: 160 tensor([[160., 161., 162., 163., 164.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([161.], device='cuda:0')
data.h5py: 161 tensor([[161., 162., 163., 164., 165.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([162.], device='cuda:0')
data.h5py: 162 tensor([[162., 163., 164., 165., 166.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([163.], device='cuda:0')
data.h5py: 163 tensor([[163., 164., 165., 166., 167.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([164.], device='cuda:0')
data.h5py: 164 tensor([[164., 165., 166., 167., 168.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([165.], device='cuda:0')
data.h5py: 165 tensor([[165., 166., 167., 168., 169.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([166.], device='cuda:0')
data.h5py: 166 tensor([[166., 167., 168., 169., 170.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([167.], device='cuda:0')
data.h5py: 167 tensor([[167., 168., 169., 170., 171.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([168.], device='cuda:0')
data.h5py: 168 tensor([[168., 169., 170., 171., 172.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([169.], device='cuda:0')
data.h5py: 169 tensor([[169., 170., 171., 172., 173.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([170.], device='cuda:0')
data.h5py: 170 tensor([[170., 171., 172., 173., 174.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([171.], device='cuda:0')
data.h5py: 171 tensor([[171., 172., 173., 174., 175.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([172.], device='cuda:0')
data.h5py: 172 tensor([[172., 173., 174., 175., 176.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([173.], device='cuda:0')
data.h5py: 173 tensor([[173., 174., 175., 176., 177.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([174.], device='cuda:0')
data.h5py: 174 tensor([[174., 175., 176., 177., 178.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([175.], device='cuda:0')
data.h5py: 175 tensor([[175., 176., 177., 178., 179.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([176.], device='cuda:0')
data.h5py: 176 tensor([[176., 177., 178., 179., 180.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([177.], device='cuda:0')
data.h5py: 177 tensor([[177., 178., 179., 180., 181.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([178.], device='cuda:0')
data.h5py: 178 tensor([[178., 179., 180., 181., 182.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([179.], device='cuda:0')
data.h5py: 179 tensor([[179., 180., 181., 182., 183.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([180.], device='cuda:0')
data.h5py: 180 tensor([[180., 181., 182., 183., 184.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([181.], device='cuda:0')
data.h5py: 181 tensor([[181., 182., 183., 184., 185.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([182.], device='cuda:0')
data.h5py: 182 tensor([[182., 183., 184., 185., 186.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([183.], device='cuda:0')
data.h5py: 183 tensor([[183., 184., 185., 186., 187.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([184.], device='cuda:0')
data.h5py: 184 tensor([[184., 185., 186., 187., 188.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([185.], device='cuda:0')
data.h5py: 185 tensor([[185., 186., 187., 188., 189.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([186.], device='cuda:0')
data.h5py: 186 tensor([[186., 187., 188., 189., 190.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([187.], device='cuda:0')
data.h5py: 187 tensor([[187., 188., 189., 190., 191.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([188.], device='cuda:0')
data.h5py: 188 tensor([[188., 189., 190., 191., 192.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([189.], device='cuda:0')
data.h5py: 189 tensor([[189., 190., 191., 192., 193.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([190.], device='cuda:0')
data.h5py: 190 tensor([[190., 191., 192., 193., 194.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([191.], device='cuda:0')
data.h5py: 191 tensor([[191., 192., 193., 194., 195.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([192.], device='cuda:0')
data.h5py: 192 tensor([[192., 193., 194., 195., 196.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([193.], device='cuda:0')
data.h5py: 193 tensor([[193., 194., 195., 196., 197.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([194.], device='cuda:0')
data.h5py: 194 tensor([[194., 195., 196., 197., 198.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([195.], device='cuda:0')
data.h5py: 195 tensor([[195., 196., 197., 198., 199.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([196.], device='cuda:0')
data.h5py: 196 tensor([[196., 197., 198., 199., 200.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([197.], device='cuda:0')
data.h5py: 197 tensor([[197., 198., 199., 200., 201.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([198.], device='cuda:0')
data.h5py: 198 tensor([[198., 199., 200., 201., 202.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([199.], device='cuda:0')
data.h5py: 199 tensor([[199., 200., 201., 202., 203.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([200.], device='cuda:0')
data.h5py: 200 tensor([[200., 201., 202., 203., 204.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([201.], device='cuda:0')
data.h5py: 201 tensor([[201., 202., 203., 204., 205.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([202.], device='cuda:0')
data.h5py: 202 tensor([[202., 203., 204., 205., 206.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([203.], device='cuda:0')
data.h5py: 203 tensor([[203., 204., 205., 206., 207.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([204.], device='cuda:0')
data.h5py: 204 tensor([[204., 205., 206., 207., 208.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([205.], device='cuda:0')
data.h5py: 205 tensor([[205., 206., 207., 208., 209.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([206.], device='cuda:0')
data.h5py: 206 tensor([[206., 207., 208., 209., 210.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([207.], device='cuda:0')
data.h5py: 207 tensor([[207., 208., 209., 210., 211.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([208.], device='cuda:0')
data.h5py: 208 tensor([[208., 209., 210., 211., 212.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([209.], device='cuda:0')
data.h5py: 209 tensor([[209., 210., 211., 212., 213.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([210.], device='cuda:0')
data.h5py: 210 tensor([[210., 211., 212., 213., 214.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([211.], device='cuda:0')
data.h5py: 211 tensor([[211., 212., 213., 214., 215.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([212.], device='cuda:0')
data.h5py: 212 tensor([[212., 213., 214., 215., 216.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([213.], device='cuda:0')
data.h5py: 213 tensor([[213., 214., 215., 216., 217.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([214.], device='cuda:0')
data.h5py: 214 tensor([[214., 215., 216., 217., 218.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([215.], device='cuda:0')
data.h5py: 215 tensor([[215., 216., 217., 218., 219.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([216.], device='cuda:0')
data.h5py: 216 tensor([[216., 217., 218., 219., 220.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([217.], device='cuda:0')
data.h5py: 217 tensor([[217., 218., 219., 220., 221.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([218.], device='cuda:0')
data.h5py: 218 tensor([[218., 219., 220., 221., 222.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([219.], device='cuda:0')
data.h5py: 219 tensor([[219., 220., 221., 222., 223.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([220.], device='cuda:0')
data.h5py: 220 tensor([[220., 221., 222., 223., 224.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([221.], device='cuda:0')
data.h5py: 221 tensor([[221., 222., 223., 224., 225.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([222.], device='cuda:0')
data.h5py: 222 tensor([[222., 223., 224., 225., 226.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([223.], device='cuda:0')
data.h5py: 223 tensor([[223., 224., 225., 226., 227.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([224.], device='cuda:0')
data.h5py: 224 tensor([[224., 225., 226., 227., 228.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([225.], device='cuda:0')
data.h5py: 225 tensor([[225., 226., 227., 228., 229.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([226.], device='cuda:0')
data.h5py: 226 tensor([[226., 227., 228., 229., 230.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([227.], device='cuda:0')
data.h5py: 227 tensor([[227., 228., 229., 230., 231.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([228.], device='cuda:0')
data.h5py: 228 tensor([[228., 229., 230., 231., 232.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([229.], device='cuda:0')
data.h5py: 229 tensor([[229., 230., 231., 232., 233.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([230.], device='cuda:0')
data.h5py: 230 tensor([[230., 231., 232., 233., 234.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([231.], device='cuda:0')
data.h5py: 231 tensor([[231., 232., 233., 234., 235.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([232.], device='cuda:0')
data.h5py: 232 tensor([[232., 233., 234., 235., 236.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([233.], device='cuda:0')
data.h5py: 233 tensor([[233., 234., 235., 236., 237.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([234.], device='cuda:0')
data.h5py: 234 tensor([[234., 235., 236., 237., 238.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([235.], device='cuda:0')
data.h5py: 235 tensor([[235., 236., 237., 238., 239.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([236.], device='cuda:0')
data.h5py: 236 tensor([[236., 237., 238., 239., 240.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([237.], device='cuda:0')
data.h5py: 237 tensor([[237., 238., 239., 240., 241.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([238.], device='cuda:0')
data.h5py: 238 tensor([[238., 239., 240., 241., 242.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([239.], device='cuda:0')
data.h5py: 239 tensor([[239., 240., 241., 242., 243.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([240.], device='cuda:0')
data.h5py: 240 tensor([[240., 241., 242., 243., 244.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([241.], device='cuda:0')
data.h5py: 241 tensor([[241., 242., 243., 244., 245.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([242.], device='cuda:0')
data.h5py: 242 tensor([[242., 243., 244., 245., 246.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([243.], device='cuda:0')
data.h5py: 243 tensor([[243., 244., 245., 246., 247.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([244.], device='cuda:0')
data.h5py: 244 tensor([[244., 245., 246., 247., 248.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([245.], device='cuda:0')
data.h5py: 245 tensor([[245., 246., 247., 248., 249.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([246.], device='cuda:0')
data.h5py: 246 tensor([[246., 247., 248., 249., 250.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([247.], device='cuda:0')
data.h5py: 247 tensor([[247., 248., 249., 250., 251.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([248.], device='cuda:0')
data.h5py: 248 tensor([[248., 249., 250., 251., 252.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([249.], device='cuda:0')
data.h5py: 249 tensor([[249., 250., 251., 252., 253.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([250.], device='cuda:0')
data.h5py: 250 tensor([[250., 251., 252., 253., 254.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([251.], device='cuda:0')
data.h5py: 251 tensor([[251., 252., 253., 254., 255.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([252.], device='cuda:0')
data.h5py: 252 tensor([[252., 253., 254., 255., 256.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([253.], device='cuda:0')
data.h5py: 253 tensor([[253., 254., 255., 256., 257.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([254.], device='cuda:0')
data.h5py: 254 tensor([[254., 255., 256., 257., 258.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([255.], device='cuda:0')
data.h5py: 255 tensor([[255., 256., 257., 258., 259.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([256.], device='cuda:0')
data.h5py: 256 tensor([[256., 257., 258., 259., 260.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([257.], device='cuda:0')
data.h5py: 257 tensor([[257., 258., 259., 260., 261.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([258.], device='cuda:0')
data.h5py: 258 tensor([[258., 259., 260., 261., 262.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([259.], device='cuda:0')
data.h5py: 259 tensor([[259., 260., 261., 262., 263.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([260.], device='cuda:0')
data.h5py: 260 tensor([[260., 261., 262., 263., 264.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([261.], device='cuda:0')
data.h5py: 261 tensor([[261., 262., 263., 264., 265.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([262.], device='cuda:0')
data.h5py: 262 tensor([[262., 263., 264., 265., 266.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([263.], device='cuda:0')
data.h5py: 263 tensor([[263., 264., 265., 266., 267.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([264.], device='cuda:0')
data.h5py: 264 tensor([[264., 265., 266., 267., 268.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([265.], device='cuda:0')
data.h5py: 265 tensor([[265., 266., 267., 268., 269.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([266.], device='cuda:0')
data.h5py: 266 tensor([[266., 267., 268., 269., 270.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([267.], device='cuda:0')
data.h5py: 267 tensor([[267., 268., 269., 270., 271.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([268.], device='cuda:0')
data.h5py: 268 tensor([[268., 269., 270., 271., 272.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([269.], device='cuda:0')
data.h5py: 269 tensor([[269., 270., 271., 272., 273.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([270.], device='cuda:0')
data.h5py: 270 tensor([[270., 271., 272., 273., 274.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([271.], device='cuda:0')
data.h5py: 271 tensor([[271., 272., 273., 274., 275.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([272.], device='cuda:0')
data.h5py: 272 tensor([[272., 273., 274., 275., 276.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([273.], device='cuda:0')
data.h5py: 273 tensor([[273., 274., 275., 276., 277.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([274.], device='cuda:0')
data.h5py: 274 tensor([[274., 275., 276., 277., 278.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([275.], device='cuda:0')
data.h5py: 275 tensor([[275., 276., 277., 278., 279.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([276.], device='cuda:0')
data.h5py: 276 tensor([[276., 277., 278., 279., 280.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([277.], device='cuda:0')
data.h5py: 277 tensor([[277., 278., 279., 280., 281.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([278.], device='cuda:0')
data.h5py: 278 tensor([[278., 279., 280., 281., 282.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([279.], device='cuda:0')
data.h5py: 279 tensor([[279., 280., 281., 282., 283.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([280.], device='cuda:0')
data.h5py: 280 tensor([[280., 281., 282., 283., 284.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([281.], device='cuda:0')
data.h5py: 281 tensor([[281., 282., 283., 284., 285.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([282.], device='cuda:0')
data.h5py: 282 tensor([[282., 283., 284., 285., 286.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([283.], device='cuda:0')
data.h5py: 283 tensor([[283., 284., 285., 286., 287.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([284.], device='cuda:0')
data.h5py: 284 tensor([[284., 285., 286., 287., 288.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([285.], device='cuda:0')
data.h5py: 285 tensor([[285., 286., 287., 288., 289.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([286.], device='cuda:0')
data.h5py: 286 tensor([[286., 287., 288., 289., 290.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([287.], device='cuda:0')
data.h5py: 287 tensor([[287., 288., 289., 290., 291.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([288.], device='cuda:0')
data.h5py: 288 tensor([[288., 289., 290., 291., 292.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([289.], device='cuda:0')
data.h5py: 289 tensor([[289., 290., 291., 292., 293.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([290.], device='cuda:0')
data.h5py: 290 tensor([[290., 291., 292., 293., 294.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([291.], device='cuda:0')
data.h5py: 291 tensor([[291., 292., 293., 294., 295.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([292.], device='cuda:0')
data.h5py: 292 tensor([[292., 293., 294., 295., 296.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([293.], device='cuda:0')
data.h5py: 293 tensor([[293., 294., 295., 296., 297.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([294.], device='cuda:0')
data.h5py: 294 tensor([[294., 295., 296., 297., 298.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([295.], device='cuda:0')
data.h5py: 295 tensor([[295., 296., 297., 298., 299.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([296.], device='cuda:0')
data.h5py: 296 tensor([[296., 297., 298., 299., 300.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([297.], device='cuda:0')
data.h5py: 297 tensor([[297., 298., 299., 300., 301.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([298.], device='cuda:0')
data.h5py: 298 tensor([[298., 299., 300., 301., 302.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([299.], device='cuda:0')
data.h5py: 299 tensor([[299., 300., 301., 302., 303.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([300.], device='cuda:0')
data.h5py: 300 tensor([[300., 301., 302., 303., 304.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([301.], device='cuda:0')
data.h5py: 301 tensor([[301., 302., 303., 304., 305.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([302.], device='cuda:0')
data.h5py: 302 tensor([[302., 303., 304., 305., 306.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([303.], device='cuda:0')
data.h5py: 303 tensor([[303., 304., 305., 306., 307.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([304.], device='cuda:0')
data.h5py: 304 tensor([[304., 305., 306., 307., 308.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([305.], device='cuda:0')
data.h5py: 305 tensor([[305., 306., 307., 308., 309.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([306.], device='cuda:0')
data.h5py: 306 tensor([[306., 307., 308., 309., 310.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([307.], device='cuda:0')
data.h5py: 307 tensor([[307., 308., 309., 310., 311.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([308.], device='cuda:0')
data.h5py: 308 tensor([[308., 309., 310., 311., 312.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([309.], device='cuda:0')
data.h5py: 309 tensor([[309., 310., 311., 312., 313.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([310.], device='cuda:0')
data.h5py: 310 tensor([[310., 311., 312., 313., 314.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([311.], device='cuda:0')
data.h5py: 311 tensor([[311., 312., 313., 314., 315.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([312.], device='cuda:0')
data.h5py: 312 tensor([[312., 313., 314., 315., 316.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([313.], device='cuda:0')
data.h5py: 313 tensor([[313., 314., 315., 316., 317.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([314.], device='cuda:0')
data.h5py: 314 tensor([[314., 315., 316., 317., 318.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([315.], device='cuda:0')
data.h5py: 315 tensor([[315., 316., 317., 318., 319.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([316.], device='cuda:0')
data.h5py: 316 tensor([[316., 317., 318., 319., 320.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([317.], device='cuda:0')
data.h5py: 317 tensor([[317., 318., 319., 320., 321.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([318.], device='cuda:0')
data.h5py: 318 tensor([[318., 319., 320., 321., 322.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([319.], device='cuda:0')
data.h5py: 319 tensor([[319., 320., 321., 322., 323.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([320.], device='cuda:0')
data.h5py: 320 tensor([[320., 321., 322., 323., 324.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([321.], device='cuda:0')
data.h5py: 321 tensor([[321., 322., 323., 324., 325.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([322.], device='cuda:0')
data.h5py: 322 tensor([[322., 323., 324., 325., 326.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([323.], device='cuda:0')
data.h5py: 323 tensor([[323., 324., 325., 326., 327.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([324.], device='cuda:0')
data.h5py: 324 tensor([[324., 325., 326., 327., 328.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([325.], device='cuda:0')
data.h5py: 325 tensor([[325., 326., 327., 328., 329.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([326.], device='cuda:0')
data.h5py: 326 tensor([[326., 327., 328., 329., 330.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([327.], device='cuda:0')
data.h5py: 327 tensor([[327., 328., 329., 330., 331.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([328.], device='cuda:0')
data.h5py: 328 tensor([[328., 329., 330., 331., 332.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([329.], device='cuda:0')
data.h5py: 329 tensor([[329., 330., 331., 332., 333.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([330.], device='cuda:0')
data.h5py: 330 tensor([[330., 331., 332., 333., 334.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([331.], device='cuda:0')
data.h5py: 331 tensor([[331., 332., 333., 334., 335.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([332.], device='cuda:0')
data.h5py: 332 tensor([[332., 333., 334., 335., 336.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([333.], device='cuda:0')
data.h5py: 333 tensor([[333., 334., 335., 336., 337.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([334.], device='cuda:0')
data.h5py: 334 tensor([[334., 335., 336., 337., 338.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([335.], device='cuda:0')
data.h5py: 335 tensor([[335., 336., 337., 338., 339.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([336.], device='cuda:0')
data.h5py: 336 tensor([[336., 337., 338., 339., 340.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([337.], device='cuda:0')
data.h5py: 337 tensor([[337., 338., 339., 340., 341.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([338.], device='cuda:0')
data.h5py: 338 tensor([[338., 339., 340., 341., 342.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([339.], device='cuda:0')
data.h5py: 339 tensor([[339., 340., 341., 342., 343.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([340.], device='cuda:0')
data.h5py: 340 tensor([[340., 341., 342., 343., 344.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([341.], device='cuda:0')
data.h5py: 341 tensor([[341., 342., 343., 344., 345.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([342.], device='cuda:0')
data.h5py: 342 tensor([[342., 343., 344., 345., 346.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([343.], device='cuda:0')
data.h5py: 343 tensor([[343., 344., 345., 346., 347.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([344.], device='cuda:0')
data.h5py: 344 tensor([[344., 345., 346., 347., 348.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([345.], device='cuda:0')
data.h5py: 345 tensor([[345., 346., 347., 348., 349.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([346.], device='cuda:0')
data.h5py: 346 tensor([[346., 347., 348., 349., 350.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([347.], device='cuda:0')
data.h5py: 347 tensor([[347., 348., 349., 350., 351.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([348.], device='cuda:0')
data.h5py: 348 tensor([[348., 349., 350., 351., 352.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([349.], device='cuda:0')
data.h5py: 349 tensor([[349., 350., 351., 352., 353.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([350.], device='cuda:0')
data.h5py: 350 tensor([[350., 351., 352., 353., 354.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([351.], device='cuda:0')
data.h5py: 351 tensor([[351., 352., 353., 354., 355.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([352.], device='cuda:0')
data.h5py: 352 tensor([[352., 353., 354., 355., 356.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([353.], device='cuda:0')
data.h5py: 353 tensor([[353., 354., 355., 356., 357.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([354.], device='cuda:0')
data.h5py: 354 tensor([[354., 355., 356., 357., 358.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([355.], device='cuda:0')
data.h5py: 355 tensor([[355., 356., 357., 358., 359.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([356.], device='cuda:0')
data.h5py: 356 tensor([[356., 357., 358., 359., 360.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([357.], device='cuda:0')
data.h5py: 357 tensor([[357., 358., 359., 360., 361.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([358.], device='cuda:0')
data.h5py: 358 tensor([[358., 359., 360., 361., 362.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([359.], device='cuda:0')
data.h5py: 359 tensor([[359., 360., 361., 362., 363.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([360.], device='cuda:0')
data.h5py: 360 tensor([[360., 361., 362., 363., 364.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([361.], device='cuda:0')
data.h5py: 361 tensor([[361., 362., 363., 364., 365.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([362.], device='cuda:0')
data.h5py: 362 tensor([[362., 363., 364., 365., 366.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([363.], device='cuda:0')
data.h5py: 363 tensor([[363., 364., 365., 366., 367.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([364.], device='cuda:0')
data.h5py: 364 tensor([[364., 365., 366., 367., 368.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([365.], device='cuda:0')
data.h5py: 365 tensor([[365., 366., 367., 368., 369.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([366.], device='cuda:0')
data.h5py: 366 tensor([[366., 367., 368., 369., 370.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([367.], device='cuda:0')
data.h5py: 367 tensor([[367., 368., 369., 370., 371.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([368.], device='cuda:0')
data.h5py: 368 tensor([[368., 369., 370., 371., 372.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([369.], device='cuda:0')
data.h5py: 369 tensor([[369., 370., 371., 372., 373.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([370.], device='cuda:0')
data.h5py: 370 tensor([[370., 371., 372., 373., 374.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([371.], device='cuda:0')
data.h5py: 371 tensor([[371., 372., 373., 374., 375.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([372.], device='cuda:0')
data.h5py: 372 tensor([[372., 373., 374., 375., 376.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([373.], device='cuda:0')
data.h5py: 373 tensor([[373., 374., 375., 376., 377.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([374.], device='cuda:0')
data.h5py: 374 tensor([[374., 375., 376., 377., 378.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([375.], device='cuda:0')
data.h5py: 375 tensor([[375., 376., 377., 378., 379.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([376.], device='cuda:0')
data.h5py: 376 tensor([[376., 377., 378., 379., 380.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([377.], device='cuda:0')
data.h5py: 377 tensor([[377., 378., 379., 380., 381.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([378.], device='cuda:0')
data.h5py: 378 tensor([[378., 379., 380., 381., 382.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([379.], device='cuda:0')
data.h5py: 379 tensor([[379., 380., 381., 382., 383.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([380.], device='cuda:0')
data.h5py: 380 tensor([[380., 381., 382., 383., 384.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([381.], device='cuda:0')
data.h5py: 381 tensor([[381., 382., 383., 384., 385.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([382.], device='cuda:0')
data.h5py: 382 tensor([[382., 383., 384., 385., 386.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([383.], device='cuda:0')
data.h5py: 383 tensor([[383., 384., 385., 386., 387.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([384.], device='cuda:0')
data.h5py: 384 tensor([[384., 385., 386., 387., 388.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([385.], device='cuda:0')
data.h5py: 385 tensor([[385., 386., 387., 388., 389.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([386.], device='cuda:0')
data.h5py: 386 tensor([[386., 387., 388., 389., 390.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([387.], device='cuda:0')
data.h5py: 387 tensor([[387., 388., 389., 390., 391.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([388.], device='cuda:0')
data.h5py: 388 tensor([[388., 389., 390., 391., 392.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([389.], device='cuda:0')
data.h5py: 389 tensor([[389., 390., 391., 392., 393.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([390.], device='cuda:0')
data.h5py: 390 tensor([[390., 391., 392., 393., 394.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([391.], device='cuda:0')
data.h5py: 391 tensor([[391., 392., 393., 394., 395.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([392.], device='cuda:0')
data.h5py: 392 tensor([[392., 393., 394., 395., 396.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([393.], device='cuda:0')
data.h5py: 393 tensor([[393., 394., 395., 396., 397.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([394.], device='cuda:0')
data.h5py: 394 tensor([[394., 395., 396., 397., 398.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([395.], device='cuda:0')
data.h5py: 395 tensor([[395., 396., 397., 398., 399.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([396.], device='cuda:0')
data.h5py: 396 tensor([[396., 397., 398., 399., 400.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([397.], device='cuda:0')
data.h5py: 397 tensor([[397., 398., 399., 400., 401.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([398.], device='cuda:0')
data.h5py: 398 tensor([[398., 399., 400., 401., 402.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([399.], device='cuda:0')
data.h5py: 399 tensor([[399., 400., 401., 402., 403.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([400.], device='cuda:0')
data.h5py: 400 tensor([[400., 401., 402., 403., 404.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([401.], device='cuda:0')
data.h5py: 401 tensor([[401., 402., 403., 404., 405.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([402.], device='cuda:0')
data.h5py: 402 tensor([[402., 403., 404., 405., 406.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([403.], device='cuda:0')
data.h5py: 403 tensor([[403., 404., 405., 406., 407.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([404.], device='cuda:0')
data.h5py: 404 tensor([[404., 405., 406., 407., 408.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([405.], device='cuda:0')
data.h5py: 405 tensor([[405., 406., 407., 408., 409.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([406.], device='cuda:0')
data.h5py: 406 tensor([[406., 407., 408., 409., 410.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([407.], device='cuda:0')
data.h5py: 407 tensor([[407., 408., 409., 410., 411.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([408.], device='cuda:0')
data.h5py: 408 tensor([[408., 409., 410., 411., 412.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([409.], device='cuda:0')
data.h5py: 409 tensor([[409., 410., 411., 412., 413.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([410.], device='cuda:0')
data.h5py: 410 tensor([[410., 411., 412., 413., 414.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([411.], device='cuda:0')
data.h5py: 411 tensor([[411., 412., 413., 414., 415.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([412.], device='cuda:0')
data.h5py: 412 tensor([[412., 413., 414., 415., 416.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([413.], device='cuda:0')
data.h5py: 413 tensor([[413., 414., 415., 416., 417.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([414.], device='cuda:0')
data.h5py: 414 tensor([[414., 415., 416., 417., 418.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([415.], device='cuda:0')
data.h5py: 415 tensor([[415., 416., 417., 418., 419.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([416.], device='cuda:0')
data.h5py: 416 tensor([[416., 417., 418., 419., 420.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([417.], device='cuda:0')
data.h5py: 417 tensor([[417., 418., 419., 420., 421.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([418.], device='cuda:0')
data.h5py: 418 tensor([[418., 419., 420., 421., 422.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([419.], device='cuda:0')
data.h5py: 419 tensor([[419., 420., 421., 422., 423.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([420.], device='cuda:0')
data.h5py: 420 tensor([[420., 421., 422., 423., 424.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([421.], device='cuda:0')
data.h5py: 421 tensor([[421., 422., 423., 424., 425.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([422.], device='cuda:0')
data.h5py: 422 tensor([[422., 423., 424., 425., 426.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([423.], device='cuda:0')
data.h5py: 423 tensor([[423., 424., 425., 426., 427.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([424.], device='cuda:0')
data.h5py: 424 tensor([[424., 425., 426., 427., 428.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([425.], device='cuda:0')
data.h5py: 425 tensor([[425., 426., 427., 428., 429.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([426.], device='cuda:0')
data.h5py: 426 tensor([[426., 427., 428., 429., 430.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([427.], device='cuda:0')
data.h5py: 427 tensor([[427., 428., 429., 430., 431.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([428.], device='cuda:0')
data.h5py: 428 tensor([[428., 429., 430., 431., 432.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([429.], device='cuda:0')
data.h5py: 429 tensor([[429., 430., 431., 432., 433.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([430.], device='cuda:0')
data.h5py: 430 tensor([[430., 431., 432., 433., 434.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([431.], device='cuda:0')
data.h5py: 431 tensor([[431., 432., 433., 434., 435.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([432.], device='cuda:0')
data.h5py: 432 tensor([[432., 433., 434., 435., 436.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([433.], device='cuda:0')
data.h5py: 433 tensor([[433., 434., 435., 436., 437.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([434.], device='cuda:0')
data.h5py: 434 tensor([[434., 435., 436., 437., 438.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([435.], device='cuda:0')
data.h5py: 435 tensor([[435., 436., 437., 438., 439.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([436.], device='cuda:0')
data.h5py: 436 tensor([[436., 437., 438., 439., 440.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([437.], device='cuda:0')
data.h5py: 437 tensor([[437., 438., 439., 440., 441.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([438.], device='cuda:0')
data.h5py: 438 tensor([[438., 439., 440., 441., 442.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([439.], device='cuda:0')
data.h5py: 439 tensor([[439., 440., 441., 442., 443.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([440.], device='cuda:0')
data.h5py: 440 tensor([[440., 441., 442., 443., 444.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([441.], device='cuda:0')
data.h5py: 441 tensor([[441., 442., 443., 444., 445.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([442.], device='cuda:0')
data.h5py: 442 tensor([[442., 443., 444., 445., 446.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([443.], device='cuda:0')
data.h5py: 443 tensor([[443., 444., 445., 446., 447.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([444.], device='cuda:0')
data.h5py: 444 tensor([[444., 445., 446., 447., 448.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([445.], device='cuda:0')
data.h5py: 445 tensor([[445., 446., 447., 448., 449.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([446.], device='cuda:0')
data.h5py: 446 tensor([[446., 447., 448., 449., 450.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([447.], device='cuda:0')
data.h5py: 447 tensor([[447., 448., 449., 450., 451.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([448.], device='cuda:0')
data.h5py: 448 tensor([[448., 449., 450., 451., 452.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([449.], device='cuda:0')
data.h5py: 449 tensor([[449., 450., 451., 452., 453.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([450.], device='cuda:0')
data.h5py: 450 tensor([[450., 451., 452., 453., 454.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([451.], device='cuda:0')
data.h5py: 451 tensor([[451., 452., 453., 454., 455.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([452.], device='cuda:0')
data.h5py: 452 tensor([[452., 453., 454., 455., 456.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([453.], device='cuda:0')
data.h5py: 453 tensor([[453., 454., 455., 456., 457.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([454.], device='cuda:0')
data.h5py: 454 tensor([[454., 455., 456., 457., 458.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([455.], device='cuda:0')
data.h5py: 455 tensor([[455., 456., 457., 458., 459.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([456.], device='cuda:0')
data.h5py: 456 tensor([[456., 457., 458., 459., 460.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([457.], device='cuda:0')
data.h5py: 457 tensor([[457., 458., 459., 460., 461.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([458.], device='cuda:0')
data.h5py: 458 tensor([[458., 459., 460., 461., 462.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([459.], device='cuda:0')
data.h5py: 459 tensor([[459., 460., 461., 462., 463.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([460.], device='cuda:0')
data.h5py: 460 tensor([[460., 461., 462., 463., 464.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([461.], device='cuda:0')
data.h5py: 461 tensor([[461., 462., 463., 464., 465.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([462.], device='cuda:0')
data.h5py: 462 tensor([[462., 463., 464., 465., 466.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([463.], device='cuda:0')
data.h5py: 463 tensor([[463., 464., 465., 466., 467.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([464.], device='cuda:0')
data.h5py: 464 tensor([[464., 465., 466., 467., 468.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([465.], device='cuda:0')
data.h5py: 465 tensor([[465., 466., 467., 468., 469.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([466.], device='cuda:0')
data.h5py: 466 tensor([[466., 467., 468., 469., 470.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([467.], device='cuda:0')
data.h5py: 467 tensor([[467., 468., 469., 470., 471.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([468.], device='cuda:0')
data.h5py: 468 tensor([[468., 469., 470., 471., 472.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([469.], device='cuda:0')
data.h5py: 469 tensor([[469., 470., 471., 472., 473.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([470.], device='cuda:0')
data.h5py: 470 tensor([[470., 471., 472., 473., 474.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([471.], device='cuda:0')
data.h5py: 471 tensor([[471., 472., 473., 474., 475.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([472.], device='cuda:0')
data.h5py: 472 tensor([[472., 473., 474., 475., 476.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([473.], device='cuda:0')
data.h5py: 473 tensor([[473., 474., 475., 476., 477.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([474.], device='cuda:0')
data.h5py: 474 tensor([[474., 475., 476., 477., 478.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([475.], device='cuda:0')
data.h5py: 475 tensor([[475., 476., 477., 478., 479.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([476.], device='cuda:0')
data.h5py: 476 tensor([[476., 477., 478., 479., 480.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([477.], device='cuda:0')
data.h5py: 477 tensor([[477., 478., 479., 480., 481.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([478.], device='cuda:0')
data.h5py: 478 tensor([[478., 479., 480., 481., 482.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([479.], device='cuda:0')
data.h5py: 479 tensor([[479., 480., 481., 482., 483.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([480.], device='cuda:0')
data.h5py: 480 tensor([[480., 481., 482., 483., 484.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([481.], device='cuda:0')
data.h5py: 481 tensor([[481., 482., 483., 484., 485.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([482.], device='cuda:0')
data.h5py: 482 tensor([[482., 483., 484., 485., 486.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([483.], device='cuda:0')
data.h5py: 483 tensor([[483., 484., 485., 486., 487.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([484.], device='cuda:0')
data.h5py: 484 tensor([[484., 485., 486., 487., 488.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([485.], device='cuda:0')
data.h5py: 485 tensor([[485., 486., 487., 488., 489.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([486.], device='cuda:0')
data.h5py: 486 tensor([[486., 487., 488., 489., 490.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([487.], device='cuda:0')
data.h5py: 487 tensor([[487., 488., 489., 490., 491.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([488.], device='cuda:0')
data.h5py: 488 tensor([[488., 489., 490., 491., 492.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([489.], device='cuda:0')
data.h5py: 489 tensor([[489., 490., 491., 492., 493.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([490.], device='cuda:0')
data.h5py: 490 tensor([[490., 491., 492., 493., 494.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([491.], device='cuda:0')
data.h5py: 491 tensor([[491., 492., 493., 494., 495.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([492.], device='cuda:0')
data.h5py: 492 tensor([[492., 493., 494., 495., 496.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([493.], device='cuda:0')
data.h5py: 493 tensor([[493., 494., 495., 496., 497.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([494.], device='cuda:0')
data.h5py: 494 tensor([[494., 495., 496., 497., 498.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([495.], device='cuda:0')
data.h5py: 495 tensor([[495., 496., 497., 498., 499.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([496.], device='cuda:0')
data.h5py: 496 tensor([[496., 497., 498., 499., 500.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([497.], device='cuda:0')
data.h5py: 497 tensor([[497., 498., 499., 500., 501.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([498.], device='cuda:0')
data.h5py: 498 tensor([[498., 499., 500., 501., 502.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([499.], device='cuda:0')
data.h5py: 499 tensor([[499., 500., 501., 502., 503.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([500.], device='cuda:0')
data.h5py: 500 tensor([[500., 501., 502., 503., 504.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([501.], device='cuda:0')
data.h5py: 501 tensor([[501., 502., 503., 504., 505.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([502.], device='cuda:0')
data.h5py: 502 tensor([[502., 503., 504., 505., 506.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([503.], device='cuda:0')
data.h5py: 503 tensor([[503., 504., 505., 506., 507.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([504.], device='cuda:0')
data.h5py: 504 tensor([[504., 505., 506., 507., 508.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([505.], device='cuda:0')
data.h5py: 505 tensor([[505., 506., 507., 508., 509.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([506.], device='cuda:0')
data.h5py: 506 tensor([[506., 507., 508., 509., 510.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([507.], device='cuda:0')
data.h5py: 507 tensor([[507., 508., 509., 510., 511.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([508.], device='cuda:0')
data.h5py: 508 tensor([[508., 509., 510., 511., 512.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([509.], device='cuda:0')
data.h5py: 509 tensor([[509., 510., 511., 512., 513.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([510.], device='cuda:0')
data.h5py: 510 tensor([[510., 511., 512., 513., 514.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([511.], device='cuda:0')
data.h5py: 511 tensor([[511., 512., 513., 514., 515.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([512.], device='cuda:0')
data.h5py: 512 tensor([[512., 513., 514., 515., 516.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([513.], device='cuda:0')
data.h5py: 513 tensor([[513., 514., 515., 516., 517.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([514.], device='cuda:0')
data.h5py: 514 tensor([[514., 515., 516., 517., 518.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([515.], device='cuda:0')
data.h5py: 515 tensor([[515., 516., 517., 518., 519.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([516.], device='cuda:0')
data.h5py: 516 tensor([[516., 517., 518., 519., 520.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([517.], device='cuda:0')
data.h5py: 517 tensor([[517., 518., 519., 520., 521.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([518.], device='cuda:0')
data.h5py: 518 tensor([[518., 519., 520., 521., 522.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([519.], device='cuda:0')
data.h5py: 519 tensor([[519., 520., 521., 522., 523.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([520.], device='cuda:0')
data.h5py: 520 tensor([[520., 521., 522., 523., 524.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([521.], device='cuda:0')
data.h5py: 521 tensor([[521., 522., 523., 524., 525.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([522.], device='cuda:0')
data.h5py: 522 tensor([[522., 523., 524., 525., 526.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([523.], device='cuda:0')
data.h5py: 523 tensor([[523., 524., 525., 526., 527.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([524.], device='cuda:0')
data.h5py: 524 tensor([[524., 525., 526., 527., 528.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([525.], device='cuda:0')
data.h5py: 525 tensor([[525., 526., 527., 528., 529.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([526.], device='cuda:0')
data.h5py: 526 tensor([[526., 527., 528., 529., 530.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([527.], device='cuda:0')
data.h5py: 527 tensor([[527., 528., 529., 530., 531.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([528.], device='cuda:0')
data.h5py: 528 tensor([[528., 529., 530., 531., 532.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([529.], device='cuda:0')
data.h5py: 529 tensor([[529., 530., 531., 532., 533.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([530.], device='cuda:0')
data.h5py: 530 tensor([[530., 531., 532., 533., 534.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([531.], device='cuda:0')
data.h5py: 531 tensor([[531., 532., 533., 534., 535.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([532.], device='cuda:0')
data.h5py: 532 tensor([[532., 533., 534., 535., 536.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([533.], device='cuda:0')
data.h5py: 533 tensor([[533., 534., 535., 536., 537.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([534.], device='cuda:0')
data.h5py: 534 tensor([[534., 535., 536., 537., 538.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([535.], device='cuda:0')
data.h5py: 535 tensor([[535., 536., 537., 538., 539.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([536.], device='cuda:0')
data.h5py: 536 tensor([[536., 537., 538., 539., 540.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([537.], device='cuda:0')
data.h5py: 537 tensor([[537., 538., 539., 540., 541.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([538.], device='cuda:0')
data.h5py: 538 tensor([[538., 539., 540., 541., 542.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([539.], device='cuda:0')
data.h5py: 539 tensor([[539., 540., 541., 542., 543.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([540.], device='cuda:0')
data.h5py: 540 tensor([[540., 541., 542., 543., 544.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([541.], device='cuda:0')
data.h5py: 541 tensor([[541., 542., 543., 544., 545.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([542.], device='cuda:0')
data.h5py: 542 tensor([[542., 543., 544., 545., 546.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([543.], device='cuda:0')
data.h5py: 543 tensor([[543., 544., 545., 546., 547.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([544.], device='cuda:0')
data.h5py: 544 tensor([[544., 545., 546., 547., 548.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([545.], device='cuda:0')
data.h5py: 545 tensor([[545., 546., 547., 548., 549.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([546.], device='cuda:0')
data.h5py: 546 tensor([[546., 547., 548., 549., 550.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([547.], device='cuda:0')
data.h5py: 547 tensor([[547., 548., 549., 550., 551.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([548.], device='cuda:0')
data.h5py: 548 tensor([[548., 549., 550., 551., 552.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([549.], device='cuda:0')
data.h5py: 549 tensor([[549., 550., 551., 552., 553.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([550.], device='cuda:0')
data.h5py: 550 tensor([[550., 551., 552., 553., 554.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([551.], device='cuda:0')
data.h5py: 551 tensor([[551., 552., 553., 554., 555.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([552.], device='cuda:0')
data.h5py: 552 tensor([[552., 553., 554., 555., 556.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([553.], device='cuda:0')
data.h5py: 553 tensor([[553., 554., 555., 556., 557.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([554.], device='cuda:0')
data.h5py: 554 tensor([[554., 555., 556., 557., 558.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([555.], device='cuda:0')
data.h5py: 555 tensor([[555., 556., 557., 558., 559.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([556.], device='cuda:0')
data.h5py: 556 tensor([[556., 557., 558., 559., 560.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([557.], device='cuda:0')
data.h5py: 557 tensor([[557., 558., 559., 560., 561.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([558.], device='cuda:0')
data.h5py: 558 tensor([[558., 559., 560., 561., 562.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([559.], device='cuda:0')
data.h5py: 559 tensor([[559., 560., 561., 562., 563.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([560.], device='cuda:0')
data.h5py: 560 tensor([[560., 561., 562., 563., 564.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([561.], device='cuda:0')
data.h5py: 561 tensor([[561., 562., 563., 564., 565.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([562.], device='cuda:0')
data.h5py: 562 tensor([[562., 563., 564., 565., 566.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([563.], device='cuda:0')
data.h5py: 563 tensor([[563., 564., 565., 566., 567.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([564.], device='cuda:0')
data.h5py: 564 tensor([[564., 565., 566., 567., 568.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([565.], device='cuda:0')
data.h5py: 565 tensor([[565., 566., 567., 568., 569.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([566.], device='cuda:0')
data.h5py: 566 tensor([[566., 567., 568., 569., 570.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([567.], device='cuda:0')
data.h5py: 567 tensor([[567., 568., 569., 570., 571.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([568.], device='cuda:0')
data.h5py: 568 tensor([[568., 569., 570., 571., 572.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([569.], device='cuda:0')
data.h5py: 569 tensor([[569., 570., 571., 572., 573.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([570.], device='cuda:0')
data.h5py: 570 tensor([[570., 571., 572., 573., 574.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([571.], device='cuda:0')
data.h5py: 571 tensor([[571., 572., 573., 574., 575.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([572.], device='cuda:0')
data.h5py: 572 tensor([[572., 573., 574., 575., 576.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([573.], device='cuda:0')
data.h5py: 573 tensor([[573., 574., 575., 576., 577.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([574.], device='cuda:0')
data.h5py: 574 tensor([[574., 575., 576., 577., 578.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([575.], device='cuda:0')
data.h5py: 575 tensor([[575., 576., 577., 578., 579.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([576.], device='cuda:0')
data.h5py: 576 tensor([[576., 577., 578., 579., 580.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([577.], device='cuda:0')
data.h5py: 577 tensor([[577., 578., 579., 580., 581.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([578.], device='cuda:0')
data.h5py: 578 tensor([[578., 579., 580., 581., 582.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([579.], device='cuda:0')
data.h5py: 579 tensor([[579., 580., 581., 582., 583.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([580.], device='cuda:0')
data.h5py: 580 tensor([[580., 581., 582., 583., 584.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([581.], device='cuda:0')
data.h5py: 581 tensor([[581., 582., 583., 584., 585.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([582.], device='cuda:0')
data.h5py: 582 tensor([[582., 583., 584., 585., 586.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([583.], device='cuda:0')
data.h5py: 583 tensor([[583., 584., 585., 586., 587.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([584.], device='cuda:0')
data.h5py: 584 tensor([[584., 585., 586., 587., 588.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([585.], device='cuda:0')
data.h5py: 585 tensor([[585., 586., 587., 588., 589.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([586.], device='cuda:0')
data.h5py: 586 tensor([[586., 587., 588., 589., 590.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([587.], device='cuda:0')
data.h5py: 587 tensor([[587., 588., 589., 590., 591.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([588.], device='cuda:0')
data.h5py: 588 tensor([[588., 589., 590., 591., 592.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([589.], device='cuda:0')
data.h5py: 589 tensor([[589., 590., 591., 592., 593.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([590.], device='cuda:0')
data.h5py: 590 tensor([[590., 591., 592., 593., 594.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([591.], device='cuda:0')
data.h5py: 591 tensor([[591., 592., 593., 594., 595.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([592.], device='cuda:0')
data.h5py: 592 tensor([[592., 593., 594., 595., 596.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([593.], device='cuda:0')
data.h5py: 593 tensor([[593., 594., 595., 596., 597.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([594.], device='cuda:0')
data.h5py: 594 tensor([[594., 595., 596., 597., 598.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([595.], device='cuda:0')
data.h5py: 595 tensor([[595., 596., 597., 598., 599.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([596.], device='cuda:0')
data.h5py: 596 tensor([[596., 597., 598., 599., 600.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([597.], device='cuda:0')
data.h5py: 597 tensor([[597., 598., 599., 600., 601.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([598.], device='cuda:0')
data.h5py: 598 tensor([[598., 599., 600., 601., 602.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([599.], device='cuda:0')
data.h5py: 599 tensor([[599., 600., 601., 602., 603.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([600.], device='cuda:0')
data.h5py: 600 tensor([[600., 601., 602., 603., 604.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([601.], device='cuda:0')
data.h5py: 601 tensor([[601., 602., 603., 604., 605.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([602.], device='cuda:0')
data.h5py: 602 tensor([[602., 603., 604., 605., 606.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([603.], device='cuda:0')
data.h5py: 603 tensor([[603., 604., 605., 606., 607.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([604.], device='cuda:0')
data.h5py: 604 tensor([[604., 605., 606., 607., 608.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([605.], device='cuda:0')
data.h5py: 605 tensor([[605., 606., 607., 608., 609.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([606.], device='cuda:0')
data.h5py: 606 tensor([[606., 607., 608., 609., 610.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([607.], device='cuda:0')
data.h5py: 607 tensor([[607., 608., 609., 610., 611.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([608.], device='cuda:0')
data.h5py: 608 tensor([[608., 609., 610., 611., 612.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([609.], device='cuda:0')
data.h5py: 609 tensor([[609., 610., 611., 612., 613.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([610.], device='cuda:0')
data.h5py: 610 tensor([[610., 611., 612., 613., 614.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([611.], device='cuda:0')
data.h5py: 611 tensor([[611., 612., 613., 614., 615.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([612.], device='cuda:0')
data.h5py: 612 tensor([[612., 613., 614., 615., 616.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([613.], device='cuda:0')
data.h5py: 613 tensor([[613., 614., 615., 616., 617.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([614.], device='cuda:0')
data.h5py: 614 tensor([[614., 615., 616., 617., 618.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([615.], device='cuda:0')
data.h5py: 615 tensor([[615., 616., 617., 618., 619.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([616.], device='cuda:0')
data.h5py: 616 tensor([[616., 617., 618., 619., 620.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([617.], device='cuda:0')
data.h5py: 617 tensor([[617., 618., 619., 620., 621.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([618.], device='cuda:0')
data.h5py: 618 tensor([[618., 619., 620., 621., 622.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([619.], device='cuda:0')
data.h5py: 619 tensor([[619., 620., 621., 622., 623.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([620.], device='cuda:0')
data.h5py: 620 tensor([[620., 621., 622., 623., 624.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([621.], device='cuda:0')
data.h5py: 621 tensor([[621., 622., 623., 624., 625.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([622.], device='cuda:0')
data.h5py: 622 tensor([[622., 623., 624., 625., 626.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([623.], device='cuda:0')
data.h5py: 623 tensor([[623., 624., 625., 626., 627.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([624.], device='cuda:0')
data.h5py: 624 tensor([[624., 625., 626., 627., 628.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([625.], device='cuda:0')
data.h5py: 625 tensor([[625., 626., 627., 628., 629.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([626.], device='cuda:0')
data.h5py: 626 tensor([[626., 627., 628., 629., 630.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([627.], device='cuda:0')
data.h5py: 627 tensor([[627., 628., 629., 630., 631.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([628.], device='cuda:0')
data.h5py: 628 tensor([[628., 629., 630., 631., 632.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([629.], device='cuda:0')
data.h5py: 629 tensor([[629., 630., 631., 632., 633.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([630.], device='cuda:0')
data.h5py: 630 tensor([[630., 631., 632., 633., 634.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([631.], device='cuda:0')
data.h5py: 631 tensor([[631., 632., 633., 634., 635.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([632.], device='cuda:0')
data.h5py: 632 tensor([[632., 633., 634., 635., 636.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([633.], device='cuda:0')
data.h5py: 633 tensor([[633., 634., 635., 636., 637.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([634.], device='cuda:0')
data.h5py: 634 tensor([[634., 635., 636., 637., 638.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([635.], device='cuda:0')
data.h5py: 635 tensor([[635., 636., 637., 638., 639.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([636.], device='cuda:0')
data.h5py: 636 tensor([[636., 637., 638., 639., 640.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([637.], device='cuda:0')
data.h5py: 637 tensor([[637., 638., 639., 640., 641.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([638.], device='cuda:0')
data.h5py: 638 tensor([[638., 639., 640., 641., 642.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([639.], device='cuda:0')
data.h5py: 639 tensor([[639., 640., 641., 642., 643.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([640.], device='cuda:0')
data.h5py: 640 tensor([[640., 641., 642., 643., 644.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([641.], device='cuda:0')
data.h5py: 641 tensor([[641., 642., 643., 644., 645.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([642.], device='cuda:0')
data.h5py: 642 tensor([[642., 643., 644., 645., 646.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([643.], device='cuda:0')
data.h5py: 643 tensor([[643., 644., 645., 646., 647.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([644.], device='cuda:0')
data.h5py: 644 tensor([[644., 645., 646., 647., 648.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([645.], device='cuda:0')
data.h5py: 645 tensor([[645., 646., 647., 648., 649.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([646.], device='cuda:0')
data.h5py: 646 tensor([[646., 647., 648., 649., 650.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([647.], device='cuda:0')
data.h5py: 647 tensor([[647., 648., 649., 650., 651.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([648.], device='cuda:0')
data.h5py: 648 tensor([[648., 649., 650., 651., 652.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([649.], device='cuda:0')
data.h5py: 649 tensor([[649., 650., 651., 652., 653.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([650.], device='cuda:0')
data.h5py: 650 tensor([[650., 651., 652., 653., 654.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([651.], device='cuda:0')
data.h5py: 651 tensor([[651., 652., 653., 654., 655.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([652.], device='cuda:0')
data.h5py: 652 tensor([[652., 653., 654., 655., 656.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([653.], device='cuda:0')
data.h5py: 653 tensor([[653., 654., 655., 656., 657.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([654.], device='cuda:0')
data.h5py: 654 tensor([[654., 655., 656., 657., 658.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([655.], device='cuda:0')
data.h5py: 655 tensor([[655., 656., 657., 658., 659.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([656.], device='cuda:0')
data.h5py: 656 tensor([[656., 657., 658., 659., 660.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([657.], device='cuda:0')
data.h5py: 657 tensor([[657., 658., 659., 660., 661.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([658.], device='cuda:0')
data.h5py: 658 tensor([[658., 659., 660., 661., 662.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([659.], device='cuda:0')
data.h5py: 659 tensor([[659., 660., 661., 662., 663.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([660.], device='cuda:0')
data.h5py: 660 tensor([[660., 661., 662., 663., 664.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([661.], device='cuda:0')
data.h5py: 661 tensor([[661., 662., 663., 664., 665.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([662.], device='cuda:0')
data.h5py: 662 tensor([[662., 663., 664., 665., 666.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([663.], device='cuda:0')
data.h5py: 663 tensor([[663., 664., 665., 666., 667.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([664.], device='cuda:0')
data.h5py: 664 tensor([[664., 665., 666., 667., 668.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([665.], device='cuda:0')
data.h5py: 665 tensor([[665., 666., 667., 668., 669.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([666.], device='cuda:0')
data.h5py: 666 tensor([[666., 667., 668., 669., 670.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([667.], device='cuda:0')
data.h5py: 667 tensor([[667., 668., 669., 670., 671.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([668.], device='cuda:0')
data.h5py: 668 tensor([[668., 669., 670., 671., 672.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([669.], device='cuda:0')
data.h5py: 669 tensor([[669., 670., 671., 672., 673.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([670.], device='cuda:0')
data.h5py: 670 tensor([[670., 671., 672., 673., 674.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([671.], device='cuda:0')
data.h5py: 671 tensor([[671., 672., 673., 674., 675.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([672.], device='cuda:0')
data.h5py: 672 tensor([[672., 673., 674., 675., 676.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([673.], device='cuda:0')
data.h5py: 673 tensor([[673., 674., 675., 676., 677.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([674.], device='cuda:0')
data.h5py: 674 tensor([[674., 675., 676., 677., 678.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([675.], device='cuda:0')
data.h5py: 675 tensor([[675., 676., 677., 678., 679.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([676.], device='cuda:0')
data.h5py: 676 tensor([[676., 677., 678., 679., 680.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([677.], device='cuda:0')
data.h5py: 677 tensor([[677., 678., 679., 680., 681.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([678.], device='cuda:0')
data.h5py: 678 tensor([[678., 679., 680., 681., 682.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([679.], device='cuda:0')
data.h5py: 679 tensor([[679., 680., 681., 682., 683.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([680.], device='cuda:0')
data.h5py: 680 tensor([[680., 681., 682., 683., 684.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([681.], device='cuda:0')
data.h5py: 681 tensor([[681., 682., 683., 684., 685.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([682.], device='cuda:0')
data.h5py: 682 tensor([[682., 683., 684., 685., 686.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([683.], device='cuda:0')
data.h5py: 683 tensor([[683., 684., 685., 686., 687.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([684.], device='cuda:0')
data.h5py: 684 tensor([[684., 685., 686., 687., 688.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([685.], device='cuda:0')
data.h5py: 685 tensor([[685., 686., 687., 688., 689.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([686.], device='cuda:0')
data.h5py: 686 tensor([[686., 687., 688., 689., 690.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([687.], device='cuda:0')
data.h5py: 687 tensor([[687., 688., 689., 690., 691.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([688.], device='cuda:0')
data.h5py: 688 tensor([[688., 689., 690., 691., 692.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([689.], device='cuda:0')
data.h5py: 689 tensor([[689., 690., 691., 692., 693.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([690.], device='cuda:0')
data.h5py: 690 tensor([[690., 691., 692., 693., 694.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([691.], device='cuda:0')
data.h5py: 691 tensor([[691., 692., 693., 694., 695.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([692.], device='cuda:0')
data.h5py: 692 tensor([[692., 693., 694., 695., 696.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([693.], device='cuda:0')
data.h5py: 693 tensor([[693., 694., 695., 696., 697.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([694.], device='cuda:0')
data.h5py: 694 tensor([[694., 695., 696., 697., 698.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([695.], device='cuda:0')
data.h5py: 695 tensor([[695., 696., 697., 698., 699.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([696.], device='cuda:0')
data.h5py: 696 tensor([[696., 697., 698., 699., 700.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([697.], device='cuda:0')
data.h5py: 697 tensor([[697., 698., 699., 700., 701.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([698.], device='cuda:0')
data.h5py: 698 tensor([[698., 699., 700., 701., 702.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([699.], device='cuda:0')
data.h5py: 699 tensor([[699., 700., 701., 702., 703.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([700.], device='cuda:0')
data.h5py: 700 tensor([[700., 701., 702., 703., 704.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([701.], device='cuda:0')
data.h5py: 701 tensor([[701., 702., 703., 704., 705.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([702.], device='cuda:0')
data.h5py: 702 tensor([[702., 703., 704., 705., 706.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([703.], device='cuda:0')
data.h5py: 703 tensor([[703., 704., 705., 706., 707.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([704.], device='cuda:0')
data.h5py: 704 tensor([[704., 705., 706., 707., 708.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([705.], device='cuda:0')
data.h5py: 705 tensor([[705., 706., 707., 708., 709.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([706.], device='cuda:0')
data.h5py: 706 tensor([[706., 707., 708., 709., 710.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([707.], device='cuda:0')
data.h5py: 707 tensor([[707., 708., 709., 710., 711.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([708.], device='cuda:0')
data.h5py: 708 tensor([[708., 709., 710., 711., 712.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([709.], device='cuda:0')
data.h5py: 709 tensor([[709., 710., 711., 712., 713.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([710.], device='cuda:0')
data.h5py: 710 tensor([[710., 711., 712., 713., 714.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([711.], device='cuda:0')
data.h5py: 711 tensor([[711., 712., 713., 714., 715.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([712.], device='cuda:0')
data.h5py: 712 tensor([[712., 713., 714., 715., 716.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([713.], device='cuda:0')
data.h5py: 713 tensor([[713., 714., 715., 716., 717.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([714.], device='cuda:0')
data.h5py: 714 tensor([[714., 715., 716., 717., 718.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([715.], device='cuda:0')
data.h5py: 715 tensor([[715., 716., 717., 718., 719.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([716.], device='cuda:0')
data.h5py: 716 tensor([[716., 717., 718., 719., 720.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([717.], device='cuda:0')
data.h5py: 717 tensor([[717., 718., 719., 720., 721.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([718.], device='cuda:0')
data.h5py: 718 tensor([[718., 719., 720., 721., 722.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([719.], device='cuda:0')
data.h5py: 719 tensor([[719., 720., 721., 722., 723.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([720.], device='cuda:0')
data.h5py: 720 tensor([[720., 721., 722., 723., 724.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([721.], device='cuda:0')
data.h5py: 721 tensor([[721., 722., 723., 724., 725.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([722.], device='cuda:0')
data.h5py: 722 tensor([[722., 723., 724., 725., 726.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([723.], device='cuda:0')
data.h5py: 723 tensor([[723., 724., 725., 726., 727.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([724.], device='cuda:0')
data.h5py: 724 tensor([[724., 725., 726., 727., 728.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([725.], device='cuda:0')
data.h5py: 725 tensor([[725., 726., 727., 728., 729.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([726.], device='cuda:0')
data.h5py: 726 tensor([[726., 727., 728., 729., 730.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([727.], device='cuda:0')
data.h5py: 727 tensor([[727., 728., 729., 730., 731.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([728.], device='cuda:0')
data.h5py: 728 tensor([[728., 729., 730., 731., 732.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([729.], device='cuda:0')
data.h5py: 729 tensor([[729., 730., 731., 732., 733.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([730.], device='cuda:0')
data.h5py: 730 tensor([[730., 731., 732., 733., 734.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([731.], device='cuda:0')
data.h5py: 731 tensor([[731., 732., 733., 734., 735.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([732.], device='cuda:0')
data.h5py: 732 tensor([[732., 733., 734., 735., 736.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([733.], device='cuda:0')
data.h5py: 733 tensor([[733., 734., 735., 736., 737.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([734.], device='cuda:0')
data.h5py: 734 tensor([[734., 735., 736., 737., 738.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([735.], device='cuda:0')
data.h5py: 735 tensor([[735., 736., 737., 738., 739.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([736.], device='cuda:0')
data.h5py: 736 tensor([[736., 737., 738., 739., 740.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([737.], device='cuda:0')
data.h5py: 737 tensor([[737., 738., 739., 740., 741.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([738.], device='cuda:0')
data.h5py: 738 tensor([[738., 739., 740., 741., 742.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([739.], device='cuda:0')
data.h5py: 739 tensor([[739., 740., 741., 742., 743.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([740.], device='cuda:0')
data.h5py: 740 tensor([[740., 741., 742., 743., 744.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([741.], device='cuda:0')
data.h5py: 741 tensor([[741., 742., 743., 744., 745.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([742.], device='cuda:0')
data.h5py: 742 tensor([[742., 743., 744., 745., 746.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([743.], device='cuda:0')
data.h5py: 743 tensor([[743., 744., 745., 746., 747.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([744.], device='cuda:0')
data.h5py: 744 tensor([[744., 745., 746., 747., 748.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([745.], device='cuda:0')
data.h5py: 745 tensor([[745., 746., 747., 748., 749.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([746.], device='cuda:0')
data.h5py: 746 tensor([[746., 747., 748., 749., 750.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([747.], device='cuda:0')
data.h5py: 747 tensor([[747., 748., 749., 750., 751.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([748.], device='cuda:0')
data.h5py: 748 tensor([[748., 749., 750., 751., 752.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([749.], device='cuda:0')
data.h5py: 749 tensor([[749., 750., 751., 752., 753.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([750.], device='cuda:0')
data.h5py: 750 tensor([[750., 751., 752., 753., 754.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([751.], device='cuda:0')
data.h5py: 751 tensor([[751., 752., 753., 754., 755.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([752.], device='cuda:0')
data.h5py: 752 tensor([[752., 753., 754., 755., 756.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([753.], device='cuda:0')
data.h5py: 753 tensor([[753., 754., 755., 756., 757.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([754.], device='cuda:0')
data.h5py: 754 tensor([[754., 755., 756., 757., 758.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([755.], device='cuda:0')
data.h5py: 755 tensor([[755., 756., 757., 758., 759.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([756.], device='cuda:0')
data.h5py: 756 tensor([[756., 757., 758., 759., 760.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([757.], device='cuda:0')
data.h5py: 757 tensor([[757., 758., 759., 760., 761.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([758.], device='cuda:0')
data.h5py: 758 tensor([[758., 759., 760., 761., 762.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([759.], device='cuda:0')
data.h5py: 759 tensor([[759., 760., 761., 762., 763.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([760.], device='cuda:0')
data.h5py: 760 tensor([[760., 761., 762., 763., 764.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([761.], device='cuda:0')
data.h5py: 761 tensor([[761., 762., 763., 764., 765.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([762.], device='cuda:0')
data.h5py: 762 tensor([[762., 763., 764., 765., 766.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([763.], device='cuda:0')
data.h5py: 763 tensor([[763., 764., 765., 766., 767.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([764.], device='cuda:0')
data.h5py: 764 tensor([[764., 765., 766., 767., 768.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([765.], device='cuda:0')
data.h5py: 765 tensor([[765., 766., 767., 768., 769.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([766.], device='cuda:0')
data.h5py: 766 tensor([[766., 767., 768., 769., 770.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([767.], device='cuda:0')
data.h5py: 767 tensor([[767., 768., 769., 770., 771.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([768.], device='cuda:0')
data.h5py: 768 tensor([[768., 769., 770., 771., 772.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([769.], device='cuda:0')
data.h5py: 769 tensor([[769., 770., 771., 772., 773.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([770.], device='cuda:0')
data.h5py: 770 tensor([[770., 771., 772., 773., 774.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([771.], device='cuda:0')
data.h5py: 771 tensor([[771., 772., 773., 774., 775.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([772.], device='cuda:0')
data.h5py: 772 tensor([[772., 773., 774., 775., 776.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([773.], device='cuda:0')
data.h5py: 773 tensor([[773., 774., 775., 776., 777.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([774.], device='cuda:0')
data.h5py: 774 tensor([[774., 775., 776., 777., 778.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([775.], device='cuda:0')
data.h5py: 775 tensor([[775., 776., 777., 778., 779.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([776.], device='cuda:0')
data.h5py: 776 tensor([[776., 777., 778., 779., 780.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([777.], device='cuda:0')
data.h5py: 777 tensor([[777., 778., 779., 780., 781.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([778.], device='cuda:0')
data.h5py: 778 tensor([[778., 779., 780., 781., 782.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([779.], device='cuda:0')
data.h5py: 779 tensor([[779., 780., 781., 782., 783.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([780.], device='cuda:0')
data.h5py: 780 tensor([[780., 781., 782., 783., 784.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([781.], device='cuda:0')
data.h5py: 781 tensor([[781., 782., 783., 784., 785.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([782.], device='cuda:0')
data.h5py: 782 tensor([[782., 783., 784., 785., 786.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([783.], device='cuda:0')
data.h5py: 783 tensor([[783., 784., 785., 786., 787.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([784.], device='cuda:0')
data.h5py: 784 tensor([[784., 785., 786., 787., 788.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([785.], device='cuda:0')
data.h5py: 785 tensor([[785., 786., 787., 788., 789.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([786.], device='cuda:0')
data.h5py: 786 tensor([[786., 787., 788., 789., 790.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([787.], device='cuda:0')
data.h5py: 787 tensor([[787., 788., 789., 790., 791.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([788.], device='cuda:0')
data.h5py: 788 tensor([[788., 789., 790., 791., 792.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([789.], device='cuda:0')
data.h5py: 789 tensor([[789., 790., 791., 792., 793.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([790.], device='cuda:0')
data.h5py: 790 tensor([[790., 791., 792., 793., 794.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([791.], device='cuda:0')
data.h5py: 791 tensor([[791., 792., 793., 794., 795.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([792.], device='cuda:0')
data.h5py: 792 tensor([[792., 793., 794., 795., 796.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([793.], device='cuda:0')
data.h5py: 793 tensor([[793., 794., 795., 796., 797.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([794.], device='cuda:0')
data.h5py: 794 tensor([[794., 795., 796., 797., 798.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([795.], device='cuda:0')
data.h5py: 795 tensor([[795., 796., 797., 798., 799.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([796.], device='cuda:0')
data.h5py: 796 tensor([[796., 797., 798., 799., 800.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([797.], device='cuda:0')
data.h5py: 797 tensor([[797., 798., 799., 800., 801.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([798.], device='cuda:0')
data.h5py: 798 tensor([[798., 799., 800., 801., 802.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([799.], device='cuda:0')
data.h5py: 799 tensor([[799., 800., 801., 802., 803.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([800.], device='cuda:0')
data.h5py: 800 tensor([[800., 801., 802., 803., 804.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([801.], device='cuda:0')
data.h5py: 801 tensor([[801., 802., 803., 804., 805.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([802.], device='cuda:0')
data.h5py: 802 tensor([[802., 803., 804., 805., 806.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([803.], device='cuda:0')
data.h5py: 803 tensor([[803., 804., 805., 806., 807.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([804.], device='cuda:0')
data.h5py: 804 tensor([[804., 805., 806., 807., 808.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([805.], device='cuda:0')
data.h5py: 805 tensor([[805., 806., 807., 808., 809.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([806.], device='cuda:0')
data.h5py: 806 tensor([[806., 807., 808., 809., 810.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([807.], device='cuda:0')
data.h5py: 807 tensor([[807., 808., 809., 810., 811.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([808.], device='cuda:0')
data.h5py: 808 tensor([[808., 809., 810., 811., 812.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([809.], device='cuda:0')
data.h5py: 809 tensor([[809., 810., 811., 812., 813.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([810.], device='cuda:0')
data.h5py: 810 tensor([[810., 811., 812., 813., 814.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([811.], device='cuda:0')
data.h5py: 811 tensor([[811., 812., 813., 814., 815.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([812.], device='cuda:0')
data.h5py: 812 tensor([[812., 813., 814., 815., 816.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([813.], device='cuda:0')
data.h5py: 813 tensor([[813., 814., 815., 816., 817.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([814.], device='cuda:0')
data.h5py: 814 tensor([[814., 815., 816., 817., 818.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([815.], device='cuda:0')
data.h5py: 815 tensor([[815., 816., 817., 818., 819.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([816.], device='cuda:0')
data.h5py: 816 tensor([[816., 817., 818., 819., 820.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([817.], device='cuda:0')
data.h5py: 817 tensor([[817., 818., 819., 820., 821.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([818.], device='cuda:0')
data.h5py: 818 tensor([[818., 819., 820., 821., 822.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([819.], device='cuda:0')
data.h5py: 819 tensor([[819., 820., 821., 822., 823.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([820.], device='cuda:0')
data.h5py: 820 tensor([[820., 821., 822., 823., 824.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([821.], device='cuda:0')
data.h5py: 821 tensor([[821., 822., 823., 824., 825.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([822.], device='cuda:0')
data.h5py: 822 tensor([[822., 823., 824., 825., 826.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([823.], device='cuda:0')
data.h5py: 823 tensor([[823., 824., 825., 826., 827.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([824.], device='cuda:0')
data.h5py: 824 tensor([[824., 825., 826., 827., 828.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([825.], device='cuda:0')
data.h5py: 825 tensor([[825., 826., 827., 828., 829.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([826.], device='cuda:0')
data.h5py: 826 tensor([[826., 827., 828., 829., 830.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([827.], device='cuda:0')
data.h5py: 827 tensor([[827., 828., 829., 830., 831.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([828.], device='cuda:0')
data.h5py: 828 tensor([[828., 829., 830., 831., 832.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([829.], device='cuda:0')
data.h5py: 829 tensor([[829., 830., 831., 832., 833.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([830.], device='cuda:0')
data.h5py: 830 tensor([[830., 831., 832., 833., 834.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([831.], device='cuda:0')
data.h5py: 831 tensor([[831., 832., 833., 834., 835.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([832.], device='cuda:0')
data.h5py: 832 tensor([[832., 833., 834., 835., 836.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([833.], device='cuda:0')
data.h5py: 833 tensor([[833., 834., 835., 836., 837.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([834.], device='cuda:0')
data.h5py: 834 tensor([[834., 835., 836., 837., 838.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([835.], device='cuda:0')
data.h5py: 835 tensor([[835., 836., 837., 838., 839.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([836.], device='cuda:0')
data.h5py: 836 tensor([[836., 837., 838., 839., 840.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([837.], device='cuda:0')
data.h5py: 837 tensor([[837., 838., 839., 840., 841.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([838.], device='cuda:0')
data.h5py: 838 tensor([[838., 839., 840., 841., 842.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([839.], device='cuda:0')
data.h5py: 839 tensor([[839., 840., 841., 842., 843.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([840.], device='cuda:0')
data.h5py: 840 tensor([[840., 841., 842., 843., 844.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([841.], device='cuda:0')
data.h5py: 841 tensor([[841., 842., 843., 844., 845.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([842.], device='cuda:0')
data.h5py: 842 tensor([[842., 843., 844., 845., 846.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([843.], device='cuda:0')
data.h5py: 843 tensor([[843., 844., 845., 846., 847.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([844.], device='cuda:0')
data.h5py: 844 tensor([[844., 845., 846., 847., 848.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([845.], device='cuda:0')
data.h5py: 845 tensor([[845., 846., 847., 848., 849.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([846.], device='cuda:0')
data.h5py: 846 tensor([[846., 847., 848., 849., 850.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([847.], device='cuda:0')
data.h5py: 847 tensor([[847., 848., 849., 850., 851.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([848.], device='cuda:0')
data.h5py: 848 tensor([[848., 849., 850., 851., 852.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([849.], device='cuda:0')
data.h5py: 849 tensor([[849., 850., 851., 852., 853.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([850.], device='cuda:0')
data.h5py: 850 tensor([[850., 851., 852., 853., 854.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([851.], device='cuda:0')
data.h5py: 851 tensor([[851., 852., 853., 854., 855.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([852.], device='cuda:0')
data.h5py: 852 tensor([[852., 853., 854., 855., 856.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([853.], device='cuda:0')
data.h5py: 853 tensor([[853., 854., 855., 856., 857.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([854.], device='cuda:0')
data.h5py: 854 tensor([[854., 855., 856., 857., 858.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([855.], device='cuda:0')
data.h5py: 855 tensor([[855., 856., 857., 858., 859.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([856.], device='cuda:0')
data.h5py: 856 tensor([[856., 857., 858., 859., 860.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([857.], device='cuda:0')
data.h5py: 857 tensor([[857., 858., 859., 860., 861.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([858.], device='cuda:0')
data.h5py: 858 tensor([[858., 859., 860., 861., 862.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([859.], device='cuda:0')
data.h5py: 859 tensor([[859., 860., 861., 862., 863.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([860.], device='cuda:0')
data.h5py: 860 tensor([[860., 861., 862., 863., 864.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([861.], device='cuda:0')
data.h5py: 861 tensor([[861., 862., 863., 864., 865.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([862.], device='cuda:0')
data.h5py: 862 tensor([[862., 863., 864., 865., 866.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([863.], device='cuda:0')
data.h5py: 863 tensor([[863., 864., 865., 866., 867.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([864.], device='cuda:0')
data.h5py: 864 tensor([[864., 865., 866., 867., 868.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([865.], device='cuda:0')
data.h5py: 865 tensor([[865., 866., 867., 868., 869.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([866.], device='cuda:0')
data.h5py: 866 tensor([[866., 867., 868., 869., 870.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([867.], device='cuda:0')
data.h5py: 867 tensor([[867., 868., 869., 870., 871.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([868.], device='cuda:0')
data.h5py: 868 tensor([[868., 869., 870., 871., 872.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([869.], device='cuda:0')
data.h5py: 869 tensor([[869., 870., 871., 872., 873.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([870.], device='cuda:0')
data.h5py: 870 tensor([[870., 871., 872., 873., 874.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([871.], device='cuda:0')
data.h5py: 871 tensor([[871., 872., 873., 874., 875.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([872.], device='cuda:0')
data.h5py: 872 tensor([[872., 873., 874., 875., 876.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([873.], device='cuda:0')
data.h5py: 873 tensor([[873., 874., 875., 876., 877.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([874.], device='cuda:0')
data.h5py: 874 tensor([[874., 875., 876., 877., 878.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([875.], device='cuda:0')
data.h5py: 875 tensor([[875., 876., 877., 878., 879.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([876.], device='cuda:0')
data.h5py: 876 tensor([[876., 877., 878., 879., 880.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([877.], device='cuda:0')
data.h5py: 877 tensor([[877., 878., 879., 880., 881.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([878.], device='cuda:0')
data.h5py: 878 tensor([[878., 879., 880., 881., 882.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([879.], device='cuda:0')
data.h5py: 879 tensor([[879., 880., 881., 882., 883.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([880.], device='cuda:0')
data.h5py: 880 tensor([[880., 881., 882., 883., 884.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([881.], device='cuda:0')
data.h5py: 881 tensor([[881., 882., 883., 884., 885.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([882.], device='cuda:0')
data.h5py: 882 tensor([[882., 883., 884., 885., 886.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([883.], device='cuda:0')
data.h5py: 883 tensor([[883., 884., 885., 886., 887.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([884.], device='cuda:0')
data.h5py: 884 tensor([[884., 885., 886., 887., 888.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([885.], device='cuda:0')
data.h5py: 885 tensor([[885., 886., 887., 888., 889.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([886.], device='cuda:0')
data.h5py: 886 tensor([[886., 887., 888., 889., 890.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([887.], device='cuda:0')
data.h5py: 887 tensor([[887., 888., 889., 890., 891.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([888.], device='cuda:0')
data.h5py: 888 tensor([[888., 889., 890., 891., 892.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([889.], device='cuda:0')
data.h5py: 889 tensor([[889., 890., 891., 892., 893.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([890.], device='cuda:0')
data.h5py: 890 tensor([[890., 891., 892., 893., 894.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([891.], device='cuda:0')
data.h5py: 891 tensor([[891., 892., 893., 894., 895.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([892.], device='cuda:0')
data.h5py: 892 tensor([[892., 893., 894., 895., 896.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([893.], device='cuda:0')
data.h5py: 893 tensor([[893., 894., 895., 896., 897.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([894.], device='cuda:0')
data.h5py: 894 tensor([[894., 895., 896., 897., 898.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([895.], device='cuda:0')
data.h5py: 895 tensor([[895., 896., 897., 898., 899.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([896.], device='cuda:0')
data.h5py: 896 tensor([[896., 897., 898., 899., 900.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([897.], device='cuda:0')
data.h5py: 897 tensor([[897., 898., 899., 900., 901.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([898.], device='cuda:0')
data.h5py: 898 tensor([[898., 899., 900., 901., 902.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([899.], device='cuda:0')
data.h5py: 899 tensor([[899., 900., 901., 902., 903.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([900.], device='cuda:0')
data.h5py: 900 tensor([[900., 901., 902., 903., 904.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([901.], device='cuda:0')
data.h5py: 901 tensor([[901., 902., 903., 904., 905.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([902.], device='cuda:0')
data.h5py: 902 tensor([[902., 903., 904., 905., 906.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([903.], device='cuda:0')
data.h5py: 903 tensor([[903., 904., 905., 906., 907.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([904.], device='cuda:0')
data.h5py: 904 tensor([[904., 905., 906., 907., 908.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([905.], device='cuda:0')
data.h5py: 905 tensor([[905., 906., 907., 908., 909.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([906.], device='cuda:0')
data.h5py: 906 tensor([[906., 907., 908., 909., 910.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([907.], device='cuda:0')
data.h5py: 907 tensor([[907., 908., 909., 910., 911.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([908.], device='cuda:0')
data.h5py: 908 tensor([[908., 909., 910., 911., 912.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([909.], device='cuda:0')
data.h5py: 909 tensor([[909., 910., 911., 912., 913.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([910.], device='cuda:0')
data.h5py: 910 tensor([[910., 911., 912., 913., 914.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([911.], device='cuda:0')
data.h5py: 911 tensor([[911., 912., 913., 914., 915.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([912.], device='cuda:0')
data.h5py: 912 tensor([[912., 913., 914., 915., 916.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([913.], device='cuda:0')
data.h5py: 913 tensor([[913., 914., 915., 916., 917.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([914.], device='cuda:0')
data.h5py: 914 tensor([[914., 915., 916., 917., 918.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([915.], device='cuda:0')
data.h5py: 915 tensor([[915., 916., 917., 918., 919.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([916.], device='cuda:0')
data.h5py: 916 tensor([[916., 917., 918., 919., 920.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([917.], device='cuda:0')
data.h5py: 917 tensor([[917., 918., 919., 920., 921.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([918.], device='cuda:0')
data.h5py: 918 tensor([[918., 919., 920., 921., 922.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([919.], device='cuda:0')
data.h5py: 919 tensor([[919., 920., 921., 922., 923.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([920.], device='cuda:0')
data.h5py: 920 tensor([[920., 921., 922., 923., 924.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([921.], device='cuda:0')
data.h5py: 921 tensor([[921., 922., 923., 924., 925.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([922.], device='cuda:0')
data.h5py: 922 tensor([[922., 923., 924., 925., 926.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([923.], device='cuda:0')
data.h5py: 923 tensor([[923., 924., 925., 926., 927.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([924.], device='cuda:0')
data.h5py: 924 tensor([[924., 925., 926., 927., 928.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([925.], device='cuda:0')
data.h5py: 925 tensor([[925., 926., 927., 928., 929.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([926.], device='cuda:0')
data.h5py: 926 tensor([[926., 927., 928., 929., 930.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([927.], device='cuda:0')
data.h5py: 927 tensor([[927., 928., 929., 930., 931.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([928.], device='cuda:0')
data.h5py: 928 tensor([[928., 929., 930., 931., 932.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([929.], device='cuda:0')
data.h5py: 929 tensor([[929., 930., 931., 932., 933.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([930.], device='cuda:0')
data.h5py: 930 tensor([[930., 931., 932., 933., 934.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([931.], device='cuda:0')
data.h5py: 931 tensor([[931., 932., 933., 934., 935.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([932.], device='cuda:0')
data.h5py: 932 tensor([[932., 933., 934., 935., 936.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([933.], device='cuda:0')
data.h5py: 933 tensor([[933., 934., 935., 936., 937.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([934.], device='cuda:0')
data.h5py: 934 tensor([[934., 935., 936., 937., 938.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([935.], device='cuda:0')
data.h5py: 935 tensor([[935., 936., 937., 938., 939.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([936.], device='cuda:0')
data.h5py: 936 tensor([[936., 937., 938., 939., 940.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([937.], device='cuda:0')
data.h5py: 937 tensor([[937., 938., 939., 940., 941.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([938.], device='cuda:0')
data.h5py: 938 tensor([[938., 939., 940., 941., 942.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([939.], device='cuda:0')
data.h5py: 939 tensor([[939., 940., 941., 942., 943.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([940.], device='cuda:0')
data.h5py: 940 tensor([[940., 941., 942., 943., 944.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([941.], device='cuda:0')
data.h5py: 941 tensor([[941., 942., 943., 944., 945.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([942.], device='cuda:0')
data.h5py: 942 tensor([[942., 943., 944., 945., 946.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([943.], device='cuda:0')
data.h5py: 943 tensor([[943., 944., 945., 946., 947.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([944.], device='cuda:0')
data.h5py: 944 tensor([[944., 945., 946., 947., 948.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([945.], device='cuda:0')
data.h5py: 945 tensor([[945., 946., 947., 948., 949.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([946.], device='cuda:0')
data.h5py: 946 tensor([[946., 947., 948., 949., 950.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([947.], device='cuda:0')
data.h5py: 947 tensor([[947., 948., 949., 950., 951.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([948.], device='cuda:0')
data.h5py: 948 tensor([[948., 949., 950., 951., 952.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([949.], device='cuda:0')
data.h5py: 949 tensor([[949., 950., 951., 952., 953.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([950.], device='cuda:0')
data.h5py: 950 tensor([[950., 951., 952., 953., 954.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([951.], device='cuda:0')
data.h5py: 951 tensor([[951., 952., 953., 954., 955.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([952.], device='cuda:0')
data.h5py: 952 tensor([[952., 953., 954., 955., 956.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([953.], device='cuda:0')
data.h5py: 953 tensor([[953., 954., 955., 956., 957.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([954.], device='cuda:0')
data.h5py: 954 tensor([[954., 955., 956., 957., 958.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([955.], device='cuda:0')
data.h5py: 955 tensor([[955., 956., 957., 958., 959.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([956.], device='cuda:0')
data.h5py: 956 tensor([[956., 957., 958., 959., 960.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([957.], device='cuda:0')
data.h5py: 957 tensor([[957., 958., 959., 960., 961.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([958.], device='cuda:0')
data.h5py: 958 tensor([[958., 959., 960., 961., 962.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([959.], device='cuda:0')
data.h5py: 959 tensor([[959., 960., 961., 962., 963.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([960.], device='cuda:0')
data.h5py: 960 tensor([[960., 961., 962., 963., 964.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([961.], device='cuda:0')
data.h5py: 961 tensor([[961., 962., 963., 964., 965.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([962.], device='cuda:0')
data.h5py: 962 tensor([[962., 963., 964., 965., 966.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([963.], device='cuda:0')
data.h5py: 963 tensor([[963., 964., 965., 966., 967.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([964.], device='cuda:0')
data.h5py: 964 tensor([[964., 965., 966., 967., 968.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([965.], device='cuda:0')
data.h5py: 965 tensor([[965., 966., 967., 968., 969.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([966.], device='cuda:0')
data.h5py: 966 tensor([[966., 967., 968., 969., 970.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([967.], device='cuda:0')
data.h5py: 967 tensor([[967., 968., 969., 970., 971.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([968.], device='cuda:0')
data.h5py: 968 tensor([[968., 969., 970., 971., 972.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([969.], device='cuda:0')
data.h5py: 969 tensor([[969., 970., 971., 972., 973.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([970.], device='cuda:0')
data.h5py: 970 tensor([[970., 971., 972., 973., 974.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([971.], device='cuda:0')
data.h5py: 971 tensor([[971., 972., 973., 974., 975.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([972.], device='cuda:0')
data.h5py: 972 tensor([[972., 973., 974., 975., 976.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([973.], device='cuda:0')
data.h5py: 973 tensor([[973., 974., 975., 976., 977.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([974.], device='cuda:0')
data.h5py: 974 tensor([[974., 975., 976., 977., 978.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([975.], device='cuda:0')
data.h5py: 975 tensor([[975., 976., 977., 978., 979.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([976.], device='cuda:0')
data.h5py: 976 tensor([[976., 977., 978., 979., 980.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([977.], device='cuda:0')
data.h5py: 977 tensor([[977., 978., 979., 980., 981.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([978.], device='cuda:0')
data.h5py: 978 tensor([[978., 979., 980., 981., 982.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([979.], device='cuda:0')
data.h5py: 979 tensor([[979., 980., 981., 982., 983.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([980.], device='cuda:0')
data.h5py: 980 tensor([[980., 981., 982., 983., 984.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([981.], device='cuda:0')
data.h5py: 981 tensor([[981., 982., 983., 984., 985.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([982.], device='cuda:0')
data.h5py: 982 tensor([[982., 983., 984., 985., 986.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([983.], device='cuda:0')
data.h5py: 983 tensor([[983., 984., 985., 986., 987.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([984.], device='cuda:0')
data.h5py: 984 tensor([[984., 985., 986., 987., 988.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([985.], device='cuda:0')
data.h5py: 985 tensor([[985., 986., 987., 988., 989.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([986.], device='cuda:0')
data.h5py: 986 tensor([[986., 987., 988., 989., 990.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([987.], device='cuda:0')
data.h5py: 987 tensor([[987., 988., 989., 990., 991.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([988.], device='cuda:0')
data.h5py: 988 tensor([[988., 989., 990., 991., 992.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([989.], device='cuda:0')
data.h5py: 989 tensor([[989., 990., 991., 992., 993.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([990.], device='cuda:0')
data.h5py: 990 tensor([[990., 991., 992., 993., 994.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([991.], device='cuda:0')
data.h5py: 991 tensor([[991., 992., 993., 994., 995.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([992.], device='cuda:0')
data.h5py: 992 tensor([[992., 993., 994., 995., 996.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([993.], device='cuda:0')
data.h5py: 993 tensor([[993., 994., 995., 996., 997.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([994.], device='cuda:0')
data.h5py: 994 tensor([[994., 995., 996., 997., 998.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([995.], device='cuda:0')
data.h5py: 995 tensor([[995., 996., 997., 998., 999.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([996.], device='cuda:0')
data.h5py: 996 tensor([[996., 997., 998., 999., 999.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([997.], device='cuda:0')
data.h5py: 997 tensor([[997., 998., 999., 999., 999.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([998.], device='cuda:0')
data.h5py: 998 tensor([[998., 999., 999., 999., 999.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([999.], device='cuda:0')
data.h5py: 999 tensor([[999., 999., 999., 999., 999.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([1000.], device='cuda:0')
Example 2
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import os
import mdnc

root_folder = 'alpha-test'
os.makedirs(root_folder, exist_ok=True)

if __name__ == '__main__':
    # Prepare the datasets.
    set_list_file = os.path.join(root_folder, 'web-data')
    mdnc.data.webtools.DataChecker.init_set_list(set_list_file)
    dc = mdnc.data.webtools.DataChecker(root=root_folder, set_list_file=set_list_file, token='', verbose=False)
    dc.add_query_file('test_data_h5cparser_seq.h5')
    dc.query()

    # Perform test.
    dset = mdnc.data.h5py.H5CParser(os.path.join(root_folder, 'test_data_h5cparser_seq'), keywords_sequence=['key1', 'key3'], keywords_single=['key2'],
                                    batch_size=1, sequence_size=5, sequence_position=-1, sequence_padding='same',
                                    shuffle=False, preprocfunc=None, num_workers=10, num_buffer=1)

    with dset.start() as p:
        for i, data in enumerate(p):
            d1, d2, d3 = data
            print('data.h5py:', i, d1[:, :], d2.shape, d3)

data.webtools: All required datasets are available.
data.h5py: 0 tensor([[0., 0., 0., 0., 0.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([1.], device='cuda:0')
data.h5py: 1 tensor([[0., 0., 0., 0., 1.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([2.], device='cuda:0')
data.h5py: 2 tensor([[0., 0., 0., 1., 2.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([3.], device='cuda:0')
data.h5py: 3 tensor([[0., 0., 1., 2., 3.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([4.], device='cuda:0')
data.h5py: 4 tensor([[0., 1., 2., 3., 4.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([5.], device='cuda:0')
data.h5py: 5 tensor([[1., 2., 3., 4., 5.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([6.], device='cuda:0')
data.h5py: 6 tensor([[2., 3., 4., 5., 6.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([7.], device='cuda:0')
data.h5py: 7 tensor([[3., 4., 5., 6., 7.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([8.], device='cuda:0')
data.h5py: 8 tensor([[4., 5., 6., 7., 8.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([9.], device='cuda:0')
data.h5py: 9 tensor([[5., 6., 7., 8., 9.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([10.], device='cuda:0')
data.h5py: 10 tensor([[ 6.,  7.,  8.,  9., 10.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([11.], device='cuda:0')
data.h5py: 11 tensor([[ 7.,  8.,  9., 10., 11.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([12.], device='cuda:0')
data.h5py: 12 tensor([[ 8.,  9., 10., 11., 12.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([13.], device='cuda:0')
data.h5py: 13 tensor([[ 9., 10., 11., 12., 13.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([14.], device='cuda:0')
data.h5py: 14 tensor([[10., 11., 12., 13., 14.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([15.], device='cuda:0')
data.h5py: 15 tensor([[11., 12., 13., 14., 15.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([16.], device='cuda:0')
data.h5py: 16 tensor([[12., 13., 14., 15., 16.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([17.], device='cuda:0')
data.h5py: 17 tensor([[13., 14., 15., 16., 17.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([18.], device='cuda:0')
data.h5py: 18 tensor([[14., 15., 16., 17., 18.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([19.], device='cuda:0')
data.h5py: 19 tensor([[15., 16., 17., 18., 19.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([20.], device='cuda:0')
data.h5py: 20 tensor([[20., 20., 20., 20., 20.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([21.], device='cuda:0')
data.h5py: 21 tensor([[20., 20., 20., 20., 21.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([22.], device='cuda:0')
data.h5py: 22 tensor([[20., 20., 20., 21., 22.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([23.], device='cuda:0')
data.h5py: 23 tensor([[20., 20., 21., 22., 23.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([24.], device='cuda:0')
data.h5py: 24 tensor([[20., 21., 22., 23., 24.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([25.], device='cuda:0')
data.h5py: 25 tensor([[21., 22., 23., 24., 25.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([26.], device='cuda:0')
data.h5py: 26 tensor([[22., 23., 24., 25., 26.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([27.], device='cuda:0')
data.h5py: 27 tensor([[23., 24., 25., 26., 27.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([28.], device='cuda:0')
data.h5py: 28 tensor([[24., 25., 26., 27., 28.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([29.], device='cuda:0')
data.h5py: 29 tensor([[25., 26., 27., 28., 29.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([30.], device='cuda:0')
data.h5py: 30 tensor([[26., 27., 28., 29., 30.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([31.], device='cuda:0')
data.h5py: 31 tensor([[27., 28., 29., 30., 31.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([32.], device='cuda:0')
data.h5py: 32 tensor([[28., 29., 30., 31., 32.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([33.], device='cuda:0')
data.h5py: 33 tensor([[29., 30., 31., 32., 33.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([34.], device='cuda:0')
data.h5py: 34 tensor([[30., 31., 32., 33., 34.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([35.], device='cuda:0')
data.h5py: 35 tensor([[31., 32., 33., 34., 35.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([36.], device='cuda:0')
data.h5py: 36 tensor([[32., 33., 34., 35., 36.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([37.], device='cuda:0')
data.h5py: 37 tensor([[33., 34., 35., 36., 37.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([38.], device='cuda:0')
data.h5py: 38 tensor([[38., 38., 38., 38., 38.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([39.], device='cuda:0')
data.h5py: 39 tensor([[38., 38., 38., 38., 39.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([40.], device='cuda:0')
data.h5py: 40 tensor([[38., 38., 38., 39., 40.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([41.], device='cuda:0')
data.h5py: 41 tensor([[38., 38., 39., 40., 41.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([42.], device='cuda:0')
data.h5py: 42 tensor([[38., 39., 40., 41., 42.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([43.], device='cuda:0')
data.h5py: 43 tensor([[39., 40., 41., 42., 43.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([44.], device='cuda:0')
data.h5py: 44 tensor([[40., 41., 42., 43., 44.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([45.], device='cuda:0')
data.h5py: 45 tensor([[41., 42., 43., 44., 45.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([46.], device='cuda:0')
data.h5py: 46 tensor([[42., 43., 44., 45., 46.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([47.], device='cuda:0')
data.h5py: 47 tensor([[43., 44., 45., 46., 47.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([48.], device='cuda:0')
data.h5py: 48 tensor([[44., 45., 46., 47., 48.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([49.], device='cuda:0')
data.h5py: 49 tensor([[45., 46., 47., 48., 49.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([50.], device='cuda:0')
data.h5py: 50 tensor([[46., 47., 48., 49., 50.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([51.], device='cuda:0')
data.h5py: 51 tensor([[51., 51., 51., 51., 51.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([52.], device='cuda:0')
data.h5py: 52 tensor([[51., 51., 51., 51., 52.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([53.], device='cuda:0')
data.h5py: 53 tensor([[51., 51., 51., 52., 53.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([54.], device='cuda:0')
data.h5py: 54 tensor([[51., 51., 52., 53., 54.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([55.], device='cuda:0')
data.h5py: 55 tensor([[51., 52., 53., 54., 55.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([56.], device='cuda:0')
data.h5py: 56 tensor([[52., 53., 54., 55., 56.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([57.], device='cuda:0')
data.h5py: 57 tensor([[53., 54., 55., 56., 57.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([58.], device='cuda:0')
data.h5py: 58 tensor([[54., 55., 56., 57., 58.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([59.], device='cuda:0')
data.h5py: 59 tensor([[55., 56., 57., 58., 59.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([60.], device='cuda:0')
data.h5py: 60 tensor([[56., 57., 58., 59., 60.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([61.], device='cuda:0')
data.h5py: 61 tensor([[57., 58., 59., 60., 61.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([62.], device='cuda:0')
data.h5py: 62 tensor([[58., 59., 60., 61., 62.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([63.], device='cuda:0')
data.h5py: 63 tensor([[59., 60., 61., 62., 63.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([64.], device='cuda:0')
data.h5py: 64 tensor([[60., 61., 62., 63., 64.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([65.], device='cuda:0')
data.h5py: 65 tensor([[61., 62., 63., 64., 65.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([66.], device='cuda:0')
data.h5py: 66 tensor([[62., 63., 64., 65., 66.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([67.], device='cuda:0')
data.h5py: 67 tensor([[63., 64., 65., 66., 67.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([68.], device='cuda:0')
data.h5py: 68 tensor([[64., 65., 66., 67., 68.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([69.], device='cuda:0')
data.h5py: 69 tensor([[65., 66., 67., 68., 69.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([70.], device='cuda:0')
data.h5py: 70 tensor([[70., 70., 70., 70., 70.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([71.], device='cuda:0')
data.h5py: 71 tensor([[70., 70., 70., 70., 71.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([72.], device='cuda:0')
data.h5py: 72 tensor([[70., 70., 70., 71., 72.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([73.], device='cuda:0')
data.h5py: 73 tensor([[70., 70., 71., 72., 73.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([74.], device='cuda:0')
data.h5py: 74 tensor([[70., 71., 72., 73., 74.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([75.], device='cuda:0')
data.h5py: 75 tensor([[71., 72., 73., 74., 75.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([76.], device='cuda:0')
data.h5py: 76 tensor([[72., 73., 74., 75., 76.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([77.], device='cuda:0')
data.h5py: 77 tensor([[73., 74., 75., 76., 77.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([78.], device='cuda:0')
data.h5py: 78 tensor([[74., 75., 76., 77., 78.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([79.], device='cuda:0')
data.h5py: 79 tensor([[75., 76., 77., 78., 79.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([80.], device='cuda:0')
data.h5py: 80 tensor([[76., 77., 78., 79., 80.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([81.], device='cuda:0')
data.h5py: 81 tensor([[77., 78., 79., 80., 81.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([82.], device='cuda:0')
data.h5py: 82 tensor([[82., 82., 82., 82., 82.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([83.], device='cuda:0')
data.h5py: 83 tensor([[82., 82., 82., 82., 83.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([84.], device='cuda:0')
data.h5py: 84 tensor([[82., 82., 82., 83., 84.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([85.], device='cuda:0')
data.h5py: 85 tensor([[82., 82., 83., 84., 85.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([86.], device='cuda:0')
data.h5py: 86 tensor([[82., 83., 84., 85., 86.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([87.], device='cuda:0')
data.h5py: 87 tensor([[83., 84., 85., 86., 87.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([88.], device='cuda:0')
data.h5py: 88 tensor([[84., 85., 86., 87., 88.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([89.], device='cuda:0')
data.h5py: 89 tensor([[85., 86., 87., 88., 89.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([90.], device='cuda:0')
data.h5py: 90 tensor([[86., 87., 88., 89., 90.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([91.], device='cuda:0')
data.h5py: 91 tensor([[87., 88., 89., 90., 91.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([92.], device='cuda:0')
data.h5py: 92 tensor([[88., 89., 90., 91., 92.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([93.], device='cuda:0')
data.h5py: 93 tensor([[89., 90., 91., 92., 93.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([94.], device='cuda:0')
data.h5py: 94 tensor([[90., 91., 92., 93., 94.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([95.], device='cuda:0')
data.h5py: 95 tensor([[91., 92., 93., 94., 95.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([96.], device='cuda:0')
data.h5py: 96 tensor([[92., 93., 94., 95., 96.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([97.], device='cuda:0')
data.h5py: 97 tensor([[93., 94., 95., 96., 97.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([98.], device='cuda:0')
data.h5py: 98 tensor([[94., 95., 96., 97., 98.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([99.], device='cuda:0')
data.h5py: 99 tensor([[95., 96., 97., 98., 99.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([100.], device='cuda:0')
data.h5py: 100 tensor([[100., 100., 100., 100., 100.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([101.], device='cuda:0')
data.h5py: 101 tensor([[100., 100., 100., 100., 101.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([102.], device='cuda:0')
data.h5py: 102 tensor([[100., 100., 100., 101., 102.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([103.], device='cuda:0')
data.h5py: 103 tensor([[100., 100., 101., 102., 103.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([104.], device='cuda:0')
data.h5py: 104 tensor([[100., 101., 102., 103., 104.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([105.], device='cuda:0')
data.h5py: 105 tensor([[101., 102., 103., 104., 105.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([106.], device='cuda:0')
data.h5py: 106 tensor([[102., 103., 104., 105., 106.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([107.], device='cuda:0')
data.h5py: 107 tensor([[103., 104., 105., 106., 107.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([108.], device='cuda:0')
data.h5py: 108 tensor([[104., 105., 106., 107., 108.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([109.], device='cuda:0')
data.h5py: 109 tensor([[105., 106., 107., 108., 109.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([110.], device='cuda:0')
data.h5py: 110 tensor([[106., 107., 108., 109., 110.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([111.], device='cuda:0')
data.h5py: 111 tensor([[107., 108., 109., 110., 111.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([112.], device='cuda:0')
data.h5py: 112 tensor([[108., 109., 110., 111., 112.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([113.], device='cuda:0')
data.h5py: 113 tensor([[109., 110., 111., 112., 113.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([114.], device='cuda:0')
data.h5py: 114 tensor([[110., 111., 112., 113., 114.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([115.], device='cuda:0')
data.h5py: 115 tensor([[111., 112., 113., 114., 115.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([116.], device='cuda:0')
data.h5py: 116 tensor([[116., 116., 116., 116., 116.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([117.], device='cuda:0')
data.h5py: 117 tensor([[116., 116., 116., 116., 117.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([118.], device='cuda:0')
data.h5py: 118 tensor([[116., 116., 116., 117., 118.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([119.], device='cuda:0')
data.h5py: 119 tensor([[116., 116., 117., 118., 119.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([120.], device='cuda:0')
data.h5py: 120 tensor([[116., 117., 118., 119., 120.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([121.], device='cuda:0')
data.h5py: 121 tensor([[117., 118., 119., 120., 121.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([122.], device='cuda:0')
data.h5py: 122 tensor([[118., 119., 120., 121., 122.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([123.], device='cuda:0')
data.h5py: 123 tensor([[119., 120., 121., 122., 123.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([124.], device='cuda:0')
data.h5py: 124 tensor([[120., 121., 122., 123., 124.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([125.], device='cuda:0')
data.h5py: 125 tensor([[121., 122., 123., 124., 125.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([126.], device='cuda:0')
data.h5py: 126 tensor([[122., 123., 124., 125., 126.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([127.], device='cuda:0')
data.h5py: 127 tensor([[123., 124., 125., 126., 127.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([128.], device='cuda:0')
data.h5py: 128 tensor([[124., 125., 126., 127., 128.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([129.], device='cuda:0')
data.h5py: 129 tensor([[125., 126., 127., 128., 129.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([130.], device='cuda:0')
data.h5py: 130 tensor([[126., 127., 128., 129., 130.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([131.], device='cuda:0')
data.h5py: 131 tensor([[127., 128., 129., 130., 131.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([132.], device='cuda:0')
data.h5py: 132 tensor([[128., 129., 130., 131., 132.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([133.], device='cuda:0')
data.h5py: 133 tensor([[129., 130., 131., 132., 133.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([134.], device='cuda:0')
data.h5py: 134 tensor([[130., 131., 132., 133., 134.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([135.], device='cuda:0')
data.h5py: 135 tensor([[131., 132., 133., 134., 135.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([136.], device='cuda:0')
data.h5py: 136 tensor([[136., 136., 136., 136., 136.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([137.], device='cuda:0')
data.h5py: 137 tensor([[136., 136., 136., 136., 137.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([138.], device='cuda:0')
data.h5py: 138 tensor([[136., 136., 136., 137., 138.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([139.], device='cuda:0')
data.h5py: 139 tensor([[136., 136., 137., 138., 139.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([140.], device='cuda:0')
data.h5py: 140 tensor([[136., 137., 138., 139., 140.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([141.], device='cuda:0')
data.h5py: 141 tensor([[137., 138., 139., 140., 141.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([142.], device='cuda:0')
data.h5py: 142 tensor([[138., 139., 140., 141., 142.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([143.], device='cuda:0')
data.h5py: 143 tensor([[139., 140., 141., 142., 143.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([144.], device='cuda:0')
data.h5py: 144 tensor([[140., 141., 142., 143., 144.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([145.], device='cuda:0')
data.h5py: 145 tensor([[141., 142., 143., 144., 145.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([146.], device='cuda:0')
data.h5py: 146 tensor([[142., 143., 144., 145., 146.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([147.], device='cuda:0')
data.h5py: 147 tensor([[143., 144., 145., 146., 147.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([148.], device='cuda:0')
data.h5py: 148 tensor([[144., 145., 146., 147., 148.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([149.], device='cuda:0')
data.h5py: 149 tensor([[145., 146., 147., 148., 149.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([150.], device='cuda:0')
data.h5py: 150 tensor([[146., 147., 148., 149., 150.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([151.], device='cuda:0')
data.h5py: 151 tensor([[147., 148., 149., 150., 151.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([152.], device='cuda:0')
data.h5py: 152 tensor([[148., 149., 150., 151., 152.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([153.], device='cuda:0')
data.h5py: 153 tensor([[153., 153., 153., 153., 153.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([154.], device='cuda:0')
data.h5py: 154 tensor([[153., 153., 153., 153., 154.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([155.], device='cuda:0')
data.h5py: 155 tensor([[153., 153., 153., 154., 155.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([156.], device='cuda:0')
data.h5py: 156 tensor([[153., 153., 154., 155., 156.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([157.], device='cuda:0')
data.h5py: 157 tensor([[153., 154., 155., 156., 157.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([158.], device='cuda:0')
data.h5py: 158 tensor([[154., 155., 156., 157., 158.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([159.], device='cuda:0')
data.h5py: 159 tensor([[155., 156., 157., 158., 159.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([160.], device='cuda:0')
data.h5py: 160 tensor([[156., 157., 158., 159., 160.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([161.], device='cuda:0')
data.h5py: 161 tensor([[157., 158., 159., 160., 161.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([162.], device='cuda:0')
data.h5py: 162 tensor([[158., 159., 160., 161., 162.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([163.], device='cuda:0')
data.h5py: 163 tensor([[159., 160., 161., 162., 163.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([164.], device='cuda:0')
data.h5py: 164 tensor([[160., 161., 162., 163., 164.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([165.], device='cuda:0')
data.h5py: 165 tensor([[161., 162., 163., 164., 165.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([166.], device='cuda:0')
data.h5py: 166 tensor([[162., 163., 164., 165., 166.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([167.], device='cuda:0')
data.h5py: 167 tensor([[163., 164., 165., 166., 167.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([168.], device='cuda:0')
data.h5py: 168 tensor([[164., 165., 166., 167., 168.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([169.], device='cuda:0')
data.h5py: 169 tensor([[165., 166., 167., 168., 169.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([170.], device='cuda:0')
data.h5py: 170 tensor([[166., 167., 168., 169., 170.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([171.], device='cuda:0')
data.h5py: 171 tensor([[167., 168., 169., 170., 171.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([172.], device='cuda:0')
data.h5py: 172 tensor([[168., 169., 170., 171., 172.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([173.], device='cuda:0')
data.h5py: 173 tensor([[173., 173., 173., 173., 173.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([174.], device='cuda:0')
data.h5py: 174 tensor([[173., 173., 173., 173., 174.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([175.], device='cuda:0')
data.h5py: 175 tensor([[173., 173., 173., 174., 175.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([176.], device='cuda:0')
data.h5py: 176 tensor([[173., 173., 174., 175., 176.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([177.], device='cuda:0')
data.h5py: 177 tensor([[173., 174., 175., 176., 177.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([178.], device='cuda:0')
data.h5py: 178 tensor([[174., 175., 176., 177., 178.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([179.], device='cuda:0')
data.h5py: 179 tensor([[175., 176., 177., 178., 179.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([180.], device='cuda:0')
data.h5py: 180 tensor([[176., 177., 178., 179., 180.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([181.], device='cuda:0')
data.h5py: 181 tensor([[177., 178., 179., 180., 181.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([182.], device='cuda:0')
data.h5py: 182 tensor([[178., 179., 180., 181., 182.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([183.], device='cuda:0')
data.h5py: 183 tensor([[179., 180., 181., 182., 183.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([184.], device='cuda:0')
data.h5py: 184 tensor([[180., 181., 182., 183., 184.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([185.], device='cuda:0')
data.h5py: 185 tensor([[181., 182., 183., 184., 185.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([186.], device='cuda:0')
data.h5py: 186 tensor([[186., 186., 186., 186., 186.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([187.], device='cuda:0')
data.h5py: 187 tensor([[186., 186., 186., 186., 187.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([188.], device='cuda:0')
data.h5py: 188 tensor([[186., 186., 186., 187., 188.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([189.], device='cuda:0')
data.h5py: 189 tensor([[186., 186., 187., 188., 189.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([190.], device='cuda:0')
data.h5py: 190 tensor([[186., 187., 188., 189., 190.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([191.], device='cuda:0')
data.h5py: 191 tensor([[187., 188., 189., 190., 191.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([192.], device='cuda:0')
data.h5py: 192 tensor([[188., 189., 190., 191., 192.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([193.], device='cuda:0')
data.h5py: 193 tensor([[189., 190., 191., 192., 193.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([194.], device='cuda:0')
data.h5py: 194 tensor([[190., 191., 192., 193., 194.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([195.], device='cuda:0')
data.h5py: 195 tensor([[191., 192., 193., 194., 195.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([196.], device='cuda:0')
data.h5py: 196 tensor([[196., 196., 196., 196., 196.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([197.], device='cuda:0')
data.h5py: 197 tensor([[196., 196., 196., 196., 197.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([198.], device='cuda:0')
data.h5py: 198 tensor([[196., 196., 196., 197., 198.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([199.], device='cuda:0')
data.h5py: 199 tensor([[196., 196., 197., 198., 199.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([200.], device='cuda:0')
data.h5py: 200 tensor([[196., 197., 198., 199., 200.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([201.], device='cuda:0')
data.h5py: 201 tensor([[197., 198., 199., 200., 201.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([202.], device='cuda:0')
data.h5py: 202 tensor([[198., 199., 200., 201., 202.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([203.], device='cuda:0')
data.h5py: 203 tensor([[199., 200., 201., 202., 203.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([204.], device='cuda:0')
data.h5py: 204 tensor([[200., 201., 202., 203., 204.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([205.], device='cuda:0')
data.h5py: 205 tensor([[201., 202., 203., 204., 205.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([206.], device='cuda:0')
data.h5py: 206 tensor([[206., 206., 206., 206., 206.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([207.], device='cuda:0')
data.h5py: 207 tensor([[206., 206., 206., 206., 207.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([208.], device='cuda:0')
data.h5py: 208 tensor([[206., 206., 206., 207., 208.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([209.], device='cuda:0')
data.h5py: 209 tensor([[206., 206., 207., 208., 209.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([210.], device='cuda:0')
data.h5py: 210 tensor([[206., 207., 208., 209., 210.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([211.], device='cuda:0')
data.h5py: 211 tensor([[207., 208., 209., 210., 211.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([212.], device='cuda:0')
data.h5py: 212 tensor([[208., 209., 210., 211., 212.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([213.], device='cuda:0')
data.h5py: 213 tensor([[209., 210., 211., 212., 213.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([214.], device='cuda:0')
data.h5py: 214 tensor([[210., 211., 212., 213., 214.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([215.], device='cuda:0')
data.h5py: 215 tensor([[211., 212., 213., 214., 215.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([216.], device='cuda:0')
data.h5py: 216 tensor([[212., 213., 214., 215., 216.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([217.], device='cuda:0')
data.h5py: 217 tensor([[217., 217., 217., 217., 217.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([218.], device='cuda:0')
data.h5py: 218 tensor([[217., 217., 217., 217., 218.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([219.], device='cuda:0')
data.h5py: 219 tensor([[217., 217., 217., 218., 219.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([220.], device='cuda:0')
data.h5py: 220 tensor([[217., 217., 218., 219., 220.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([221.], device='cuda:0')
data.h5py: 221 tensor([[217., 218., 219., 220., 221.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([222.], device='cuda:0')
data.h5py: 222 tensor([[218., 219., 220., 221., 222.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([223.], device='cuda:0')
data.h5py: 223 tensor([[219., 220., 221., 222., 223.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([224.], device='cuda:0')
data.h5py: 224 tensor([[220., 221., 222., 223., 224.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([225.], device='cuda:0')
data.h5py: 225 tensor([[221., 222., 223., 224., 225.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([226.], device='cuda:0')
data.h5py: 226 tensor([[222., 223., 224., 225., 226.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([227.], device='cuda:0')
data.h5py: 227 tensor([[223., 224., 225., 226., 227.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([228.], device='cuda:0')
data.h5py: 228 tensor([[224., 225., 226., 227., 228.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([229.], device='cuda:0')
data.h5py: 229 tensor([[225., 226., 227., 228., 229.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([230.], device='cuda:0')
data.h5py: 230 tensor([[226., 227., 228., 229., 230.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([231.], device='cuda:0')
data.h5py: 231 tensor([[227., 228., 229., 230., 231.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([232.], device='cuda:0')
data.h5py: 232 tensor([[228., 229., 230., 231., 232.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([233.], device='cuda:0')
data.h5py: 233 tensor([[233., 233., 233., 233., 233.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([234.], device='cuda:0')
data.h5py: 234 tensor([[233., 233., 233., 233., 234.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([235.], device='cuda:0')
data.h5py: 235 tensor([[233., 233., 233., 234., 235.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([236.], device='cuda:0')
data.h5py: 236 tensor([[233., 233., 234., 235., 236.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([237.], device='cuda:0')
data.h5py: 237 tensor([[233., 234., 235., 236., 237.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([238.], device='cuda:0')
data.h5py: 238 tensor([[234., 235., 236., 237., 238.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([239.], device='cuda:0')
data.h5py: 239 tensor([[235., 236., 237., 238., 239.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([240.], device='cuda:0')
data.h5py: 240 tensor([[236., 237., 238., 239., 240.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([241.], device='cuda:0')
data.h5py: 241 tensor([[237., 238., 239., 240., 241.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([242.], device='cuda:0')
data.h5py: 242 tensor([[238., 239., 240., 241., 242.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([243.], device='cuda:0')
data.h5py: 243 tensor([[239., 240., 241., 242., 243.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([244.], device='cuda:0')
data.h5py: 244 tensor([[240., 241., 242., 243., 244.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([245.], device='cuda:0')
data.h5py: 245 tensor([[241., 242., 243., 244., 245.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([246.], device='cuda:0')
data.h5py: 246 tensor([[242., 243., 244., 245., 246.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([247.], device='cuda:0')
data.h5py: 247 tensor([[243., 244., 245., 246., 247.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([248.], device='cuda:0')
data.h5py: 248 tensor([[244., 245., 246., 247., 248.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([249.], device='cuda:0')
data.h5py: 249 tensor([[245., 246., 247., 248., 249.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([250.], device='cuda:0')
data.h5py: 250 tensor([[246., 247., 248., 249., 250.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([251.], device='cuda:0')
data.h5py: 251 tensor([[247., 248., 249., 250., 251.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([252.], device='cuda:0')
data.h5py: 252 tensor([[248., 249., 250., 251., 252.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([253.], device='cuda:0')
data.h5py: 253 tensor([[253., 253., 253., 253., 253.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([254.], device='cuda:0')
data.h5py: 254 tensor([[253., 253., 253., 253., 254.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([255.], device='cuda:0')
data.h5py: 255 tensor([[253., 253., 253., 254., 255.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([256.], device='cuda:0')
data.h5py: 256 tensor([[253., 253., 254., 255., 256.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([257.], device='cuda:0')
data.h5py: 257 tensor([[253., 254., 255., 256., 257.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([258.], device='cuda:0')
data.h5py: 258 tensor([[254., 255., 256., 257., 258.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([259.], device='cuda:0')
data.h5py: 259 tensor([[255., 256., 257., 258., 259.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([260.], device='cuda:0')
data.h5py: 260 tensor([[256., 257., 258., 259., 260.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([261.], device='cuda:0')
data.h5py: 261 tensor([[257., 258., 259., 260., 261.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([262.], device='cuda:0')
data.h5py: 262 tensor([[258., 259., 260., 261., 262.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([263.], device='cuda:0')
data.h5py: 263 tensor([[259., 260., 261., 262., 263.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([264.], device='cuda:0')
data.h5py: 264 tensor([[260., 261., 262., 263., 264.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([265.], device='cuda:0')
data.h5py: 265 tensor([[261., 262., 263., 264., 265.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([266.], device='cuda:0')
data.h5py: 266 tensor([[262., 263., 264., 265., 266.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([267.], device='cuda:0')
data.h5py: 267 tensor([[263., 264., 265., 266., 267.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([268.], device='cuda:0')
data.h5py: 268 tensor([[264., 265., 266., 267., 268.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([269.], device='cuda:0')
data.h5py: 269 tensor([[265., 266., 267., 268., 269.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([270.], device='cuda:0')
data.h5py: 270 tensor([[266., 267., 268., 269., 270.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([271.], device='cuda:0')
data.h5py: 271 tensor([[271., 271., 271., 271., 271.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([272.], device='cuda:0')
data.h5py: 272 tensor([[271., 271., 271., 271., 272.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([273.], device='cuda:0')
data.h5py: 273 tensor([[271., 271., 271., 272., 273.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([274.], device='cuda:0')
data.h5py: 274 tensor([[271., 271., 272., 273., 274.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([275.], device='cuda:0')
data.h5py: 275 tensor([[271., 272., 273., 274., 275.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([276.], device='cuda:0')
data.h5py: 276 tensor([[272., 273., 274., 275., 276.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([277.], device='cuda:0')
data.h5py: 277 tensor([[273., 274., 275., 276., 277.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([278.], device='cuda:0')
data.h5py: 278 tensor([[274., 275., 276., 277., 278.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([279.], device='cuda:0')
data.h5py: 279 tensor([[275., 276., 277., 278., 279.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([280.], device='cuda:0')
data.h5py: 280 tensor([[276., 277., 278., 279., 280.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([281.], device='cuda:0')
data.h5py: 281 tensor([[277., 278., 279., 280., 281.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([282.], device='cuda:0')
data.h5py: 282 tensor([[278., 279., 280., 281., 282.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([283.], device='cuda:0')
data.h5py: 283 tensor([[279., 280., 281., 282., 283.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([284.], device='cuda:0')
data.h5py: 284 tensor([[280., 281., 282., 283., 284.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([285.], device='cuda:0')
data.h5py: 285 tensor([[281., 282., 283., 284., 285.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([286.], device='cuda:0')
data.h5py: 286 tensor([[282., 283., 284., 285., 286.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([287.], device='cuda:0')
data.h5py: 287 tensor([[283., 284., 285., 286., 287.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([288.], device='cuda:0')
data.h5py: 288 tensor([[288., 288., 288., 288., 288.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([289.], device='cuda:0')
data.h5py: 289 tensor([[288., 288., 288., 288., 289.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([290.], device='cuda:0')
data.h5py: 290 tensor([[288., 288., 288., 289., 290.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([291.], device='cuda:0')
data.h5py: 291 tensor([[288., 288., 289., 290., 291.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([292.], device='cuda:0')
data.h5py: 292 tensor([[288., 289., 290., 291., 292.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([293.], device='cuda:0')
data.h5py: 293 tensor([[289., 290., 291., 292., 293.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([294.], device='cuda:0')
data.h5py: 294 tensor([[290., 291., 292., 293., 294.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([295.], device='cuda:0')
data.h5py: 295 tensor([[291., 292., 293., 294., 295.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([296.], device='cuda:0')
data.h5py: 296 tensor([[292., 293., 294., 295., 296.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([297.], device='cuda:0')
data.h5py: 297 tensor([[293., 294., 295., 296., 297.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([298.], device='cuda:0')
data.h5py: 298 tensor([[298., 298., 298., 298., 298.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([299.], device='cuda:0')
data.h5py: 299 tensor([[298., 298., 298., 298., 299.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([300.], device='cuda:0')
data.h5py: 300 tensor([[298., 298., 298., 299., 300.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([301.], device='cuda:0')
data.h5py: 301 tensor([[298., 298., 299., 300., 301.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([302.], device='cuda:0')
data.h5py: 302 tensor([[298., 299., 300., 301., 302.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([303.], device='cuda:0')
data.h5py: 303 tensor([[299., 300., 301., 302., 303.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([304.], device='cuda:0')
data.h5py: 304 tensor([[300., 301., 302., 303., 304.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([305.], device='cuda:0')
data.h5py: 305 tensor([[301., 302., 303., 304., 305.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([306.], device='cuda:0')
data.h5py: 306 tensor([[302., 303., 304., 305., 306.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([307.], device='cuda:0')
data.h5py: 307 tensor([[303., 304., 305., 306., 307.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([308.], device='cuda:0')
data.h5py: 308 tensor([[304., 305., 306., 307., 308.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([309.], device='cuda:0')
data.h5py: 309 tensor([[305., 306., 307., 308., 309.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([310.], device='cuda:0')
data.h5py: 310 tensor([[310., 310., 310., 310., 310.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([311.], device='cuda:0')
data.h5py: 311 tensor([[310., 310., 310., 310., 311.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([312.], device='cuda:0')
data.h5py: 312 tensor([[310., 310., 310., 311., 312.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([313.], device='cuda:0')
data.h5py: 313 tensor([[310., 310., 311., 312., 313.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([314.], device='cuda:0')
data.h5py: 314 tensor([[310., 311., 312., 313., 314.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([315.], device='cuda:0')
data.h5py: 315 tensor([[311., 312., 313., 314., 315.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([316.], device='cuda:0')
data.h5py: 316 tensor([[312., 313., 314., 315., 316.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([317.], device='cuda:0')
data.h5py: 317 tensor([[313., 314., 315., 316., 317.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([318.], device='cuda:0')
data.h5py: 318 tensor([[314., 315., 316., 317., 318.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([319.], device='cuda:0')
data.h5py: 319 tensor([[315., 316., 317., 318., 319.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([320.], device='cuda:0')
data.h5py: 320 tensor([[316., 317., 318., 319., 320.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([321.], device='cuda:0')
data.h5py: 321 tensor([[317., 318., 319., 320., 321.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([322.], device='cuda:0')
data.h5py: 322 tensor([[318., 319., 320., 321., 322.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([323.], device='cuda:0')
data.h5py: 323 tensor([[319., 320., 321., 322., 323.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([324.], device='cuda:0')
data.h5py: 324 tensor([[324., 324., 324., 324., 324.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([325.], device='cuda:0')
data.h5py: 325 tensor([[324., 324., 324., 324., 325.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([326.], device='cuda:0')
data.h5py: 326 tensor([[324., 324., 324., 325., 326.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([327.], device='cuda:0')
data.h5py: 327 tensor([[324., 324., 325., 326., 327.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([328.], device='cuda:0')
data.h5py: 328 tensor([[324., 325., 326., 327., 328.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([329.], device='cuda:0')
data.h5py: 329 tensor([[325., 326., 327., 328., 329.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([330.], device='cuda:0')
data.h5py: 330 tensor([[326., 327., 328., 329., 330.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([331.], device='cuda:0')
data.h5py: 331 tensor([[327., 328., 329., 330., 331.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([332.], device='cuda:0')
data.h5py: 332 tensor([[328., 329., 330., 331., 332.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([333.], device='cuda:0')
data.h5py: 333 tensor([[329., 330., 331., 332., 333.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([334.], device='cuda:0')
data.h5py: 334 tensor([[334., 334., 334., 334., 334.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([335.], device='cuda:0')
data.h5py: 335 tensor([[334., 334., 334., 334., 335.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([336.], device='cuda:0')
data.h5py: 336 tensor([[334., 334., 334., 335., 336.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([337.], device='cuda:0')
data.h5py: 337 tensor([[334., 334., 335., 336., 337.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([338.], device='cuda:0')
data.h5py: 338 tensor([[334., 335., 336., 337., 338.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([339.], device='cuda:0')
data.h5py: 339 tensor([[335., 336., 337., 338., 339.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([340.], device='cuda:0')
data.h5py: 340 tensor([[336., 337., 338., 339., 340.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([341.], device='cuda:0')
data.h5py: 341 tensor([[337., 338., 339., 340., 341.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([342.], device='cuda:0')
data.h5py: 342 tensor([[338., 339., 340., 341., 342.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([343.], device='cuda:0')
data.h5py: 343 tensor([[339., 340., 341., 342., 343.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([344.], device='cuda:0')
data.h5py: 344 tensor([[340., 341., 342., 343., 344.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([345.], device='cuda:0')
data.h5py: 345 tensor([[341., 342., 343., 344., 345.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([346.], device='cuda:0')
data.h5py: 346 tensor([[342., 343., 344., 345., 346.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([347.], device='cuda:0')
data.h5py: 347 tensor([[343., 344., 345., 346., 347.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([348.], device='cuda:0')
data.h5py: 348 tensor([[344., 345., 346., 347., 348.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([349.], device='cuda:0')
data.h5py: 349 tensor([[345., 346., 347., 348., 349.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([350.], device='cuda:0')
data.h5py: 350 tensor([[346., 347., 348., 349., 350.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([351.], device='cuda:0')
data.h5py: 351 tensor([[347., 348., 349., 350., 351.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([352.], device='cuda:0')
data.h5py: 352 tensor([[348., 349., 350., 351., 352.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([353.], device='cuda:0')
data.h5py: 353 tensor([[349., 350., 351., 352., 353.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([354.], device='cuda:0')
data.h5py: 354 tensor([[354., 354., 354., 354., 354.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([355.], device='cuda:0')
data.h5py: 355 tensor([[354., 354., 354., 354., 355.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([356.], device='cuda:0')
data.h5py: 356 tensor([[354., 354., 354., 355., 356.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([357.], device='cuda:0')
data.h5py: 357 tensor([[354., 354., 355., 356., 357.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([358.], device='cuda:0')
data.h5py: 358 tensor([[354., 355., 356., 357., 358.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([359.], device='cuda:0')
data.h5py: 359 tensor([[355., 356., 357., 358., 359.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([360.], device='cuda:0')
data.h5py: 360 tensor([[356., 357., 358., 359., 360.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([361.], device='cuda:0')
data.h5py: 361 tensor([[357., 358., 359., 360., 361.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([362.], device='cuda:0')
data.h5py: 362 tensor([[358., 359., 360., 361., 362.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([363.], device='cuda:0')
data.h5py: 363 tensor([[359., 360., 361., 362., 363.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([364.], device='cuda:0')
data.h5py: 364 tensor([[360., 361., 362., 363., 364.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([365.], device='cuda:0')
data.h5py: 365 tensor([[361., 362., 363., 364., 365.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([366.], device='cuda:0')
data.h5py: 366 tensor([[362., 363., 364., 365., 366.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([367.], device='cuda:0')
data.h5py: 367 tensor([[363., 364., 365., 366., 367.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([368.], device='cuda:0')
data.h5py: 368 tensor([[364., 365., 366., 367., 368.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([369.], device='cuda:0')
data.h5py: 369 tensor([[365., 366., 367., 368., 369.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([370.], device='cuda:0')
data.h5py: 370 tensor([[370., 370., 370., 370., 370.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([371.], device='cuda:0')
data.h5py: 371 tensor([[370., 370., 370., 370., 371.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([372.], device='cuda:0')
data.h5py: 372 tensor([[370., 370., 370., 371., 372.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([373.], device='cuda:0')
data.h5py: 373 tensor([[370., 370., 371., 372., 373.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([374.], device='cuda:0')
data.h5py: 374 tensor([[370., 371., 372., 373., 374.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([375.], device='cuda:0')
data.h5py: 375 tensor([[371., 372., 373., 374., 375.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([376.], device='cuda:0')
data.h5py: 376 tensor([[372., 373., 374., 375., 376.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([377.], device='cuda:0')
data.h5py: 377 tensor([[373., 374., 375., 376., 377.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([378.], device='cuda:0')
data.h5py: 378 tensor([[374., 375., 376., 377., 378.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([379.], device='cuda:0')
data.h5py: 379 tensor([[375., 376., 377., 378., 379.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([380.], device='cuda:0')
data.h5py: 380 tensor([[380., 380., 380., 380., 380.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([381.], device='cuda:0')
data.h5py: 381 tensor([[380., 380., 380., 380., 381.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([382.], device='cuda:0')
data.h5py: 382 tensor([[380., 380., 380., 381., 382.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([383.], device='cuda:0')
data.h5py: 383 tensor([[380., 380., 381., 382., 383.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([384.], device='cuda:0')
data.h5py: 384 tensor([[380., 381., 382., 383., 384.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([385.], device='cuda:0')
data.h5py: 385 tensor([[381., 382., 383., 384., 385.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([386.], device='cuda:0')
data.h5py: 386 tensor([[382., 383., 384., 385., 386.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([387.], device='cuda:0')
data.h5py: 387 tensor([[383., 384., 385., 386., 387.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([388.], device='cuda:0')
data.h5py: 388 tensor([[384., 385., 386., 387., 388.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([389.], device='cuda:0')
data.h5py: 389 tensor([[385., 386., 387., 388., 389.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([390.], device='cuda:0')
data.h5py: 390 tensor([[386., 387., 388., 389., 390.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([391.], device='cuda:0')
data.h5py: 391 tensor([[387., 388., 389., 390., 391.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([392.], device='cuda:0')
data.h5py: 392 tensor([[388., 389., 390., 391., 392.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([393.], device='cuda:0')
data.h5py: 393 tensor([[389., 390., 391., 392., 393.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([394.], device='cuda:0')
data.h5py: 394 tensor([[390., 391., 392., 393., 394.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([395.], device='cuda:0')
data.h5py: 395 tensor([[395., 395., 395., 395., 395.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([396.], device='cuda:0')
data.h5py: 396 tensor([[395., 395., 395., 395., 396.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([397.], device='cuda:0')
data.h5py: 397 tensor([[395., 395., 395., 396., 397.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([398.], device='cuda:0')
data.h5py: 398 tensor([[395., 395., 396., 397., 398.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([399.], device='cuda:0')
data.h5py: 399 tensor([[395., 396., 397., 398., 399.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([400.], device='cuda:0')
data.h5py: 400 tensor([[396., 397., 398., 399., 400.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([401.], device='cuda:0')
data.h5py: 401 tensor([[397., 398., 399., 400., 401.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([402.], device='cuda:0')
data.h5py: 402 tensor([[398., 399., 400., 401., 402.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([403.], device='cuda:0')
data.h5py: 403 tensor([[399., 400., 401., 402., 403.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([404.], device='cuda:0')
data.h5py: 404 tensor([[400., 401., 402., 403., 404.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([405.], device='cuda:0')
data.h5py: 405 tensor([[401., 402., 403., 404., 405.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([406.], device='cuda:0')
data.h5py: 406 tensor([[402., 403., 404., 405., 406.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([407.], device='cuda:0')
data.h5py: 407 tensor([[403., 404., 405., 406., 407.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([408.], device='cuda:0')
data.h5py: 408 tensor([[408., 408., 408., 408., 408.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([409.], device='cuda:0')
data.h5py: 409 tensor([[408., 408., 408., 408., 409.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([410.], device='cuda:0')
data.h5py: 410 tensor([[408., 408., 408., 409., 410.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([411.], device='cuda:0')
data.h5py: 411 tensor([[408., 408., 409., 410., 411.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([412.], device='cuda:0')
data.h5py: 412 tensor([[408., 409., 410., 411., 412.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([413.], device='cuda:0')
data.h5py: 413 tensor([[409., 410., 411., 412., 413.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([414.], device='cuda:0')
data.h5py: 414 tensor([[410., 411., 412., 413., 414.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([415.], device='cuda:0')
data.h5py: 415 tensor([[411., 412., 413., 414., 415.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([416.], device='cuda:0')
data.h5py: 416 tensor([[412., 413., 414., 415., 416.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([417.], device='cuda:0')
data.h5py: 417 tensor([[413., 414., 415., 416., 417.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([418.], device='cuda:0')
data.h5py: 418 tensor([[414., 415., 416., 417., 418.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([419.], device='cuda:0')
data.h5py: 419 tensor([[415., 416., 417., 418., 419.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([420.], device='cuda:0')
data.h5py: 420 tensor([[416., 417., 418., 419., 420.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([421.], device='cuda:0')
data.h5py: 421 tensor([[417., 418., 419., 420., 421.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([422.], device='cuda:0')
data.h5py: 422 tensor([[418., 419., 420., 421., 422.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([423.], device='cuda:0')
data.h5py: 423 tensor([[419., 420., 421., 422., 423.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([424.], device='cuda:0')
data.h5py: 424 tensor([[420., 421., 422., 423., 424.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([425.], device='cuda:0')
data.h5py: 425 tensor([[421., 422., 423., 424., 425.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([426.], device='cuda:0')
data.h5py: 426 tensor([[422., 423., 424., 425., 426.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([427.], device='cuda:0')
data.h5py: 427 tensor([[423., 424., 425., 426., 427.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([428.], device='cuda:0')
data.h5py: 428 tensor([[428., 428., 428., 428., 428.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([429.], device='cuda:0')
data.h5py: 429 tensor([[428., 428., 428., 428., 429.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([430.], device='cuda:0')
data.h5py: 430 tensor([[428., 428., 428., 429., 430.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([431.], device='cuda:0')
data.h5py: 431 tensor([[428., 428., 429., 430., 431.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([432.], device='cuda:0')
data.h5py: 432 tensor([[428., 429., 430., 431., 432.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([433.], device='cuda:0')
data.h5py: 433 tensor([[429., 430., 431., 432., 433.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([434.], device='cuda:0')
data.h5py: 434 tensor([[430., 431., 432., 433., 434.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([435.], device='cuda:0')
data.h5py: 435 tensor([[431., 432., 433., 434., 435.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([436.], device='cuda:0')
data.h5py: 436 tensor([[432., 433., 434., 435., 436.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([437.], device='cuda:0')
data.h5py: 437 tensor([[433., 434., 435., 436., 437.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([438.], device='cuda:0')
data.h5py: 438 tensor([[434., 435., 436., 437., 438.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([439.], device='cuda:0')
data.h5py: 439 tensor([[435., 436., 437., 438., 439.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([440.], device='cuda:0')
data.h5py: 440 tensor([[436., 437., 438., 439., 440.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([441.], device='cuda:0')
data.h5py: 441 tensor([[437., 438., 439., 440., 441.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([442.], device='cuda:0')
data.h5py: 442 tensor([[438., 439., 440., 441., 442.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([443.], device='cuda:0')
data.h5py: 443 tensor([[439., 440., 441., 442., 443.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([444.], device='cuda:0')
data.h5py: 444 tensor([[440., 441., 442., 443., 444.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([445.], device='cuda:0')
data.h5py: 445 tensor([[441., 442., 443., 444., 445.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([446.], device='cuda:0')
data.h5py: 446 tensor([[442., 443., 444., 445., 446.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([447.], device='cuda:0')
data.h5py: 447 tensor([[443., 444., 445., 446., 447.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([448.], device='cuda:0')
data.h5py: 448 tensor([[448., 448., 448., 448., 448.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([449.], device='cuda:0')
data.h5py: 449 tensor([[448., 448., 448., 448., 449.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([450.], device='cuda:0')
data.h5py: 450 tensor([[448., 448., 448., 449., 450.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([451.], device='cuda:0')
data.h5py: 451 tensor([[448., 448., 449., 450., 451.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([452.], device='cuda:0')
data.h5py: 452 tensor([[448., 449., 450., 451., 452.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([453.], device='cuda:0')
data.h5py: 453 tensor([[449., 450., 451., 452., 453.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([454.], device='cuda:0')
data.h5py: 454 tensor([[450., 451., 452., 453., 454.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([455.], device='cuda:0')
data.h5py: 455 tensor([[451., 452., 453., 454., 455.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([456.], device='cuda:0')
data.h5py: 456 tensor([[452., 453., 454., 455., 456.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([457.], device='cuda:0')
data.h5py: 457 tensor([[453., 454., 455., 456., 457.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([458.], device='cuda:0')
data.h5py: 458 tensor([[454., 455., 456., 457., 458.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([459.], device='cuda:0')
data.h5py: 459 tensor([[455., 456., 457., 458., 459.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([460.], device='cuda:0')
data.h5py: 460 tensor([[456., 457., 458., 459., 460.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([461.], device='cuda:0')
data.h5py: 461 tensor([[457., 458., 459., 460., 461.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([462.], device='cuda:0')
data.h5py: 462 tensor([[458., 459., 460., 461., 462.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([463.], device='cuda:0')
data.h5py: 463 tensor([[459., 460., 461., 462., 463.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([464.], device='cuda:0')
data.h5py: 464 tensor([[460., 461., 462., 463., 464.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([465.], device='cuda:0')
data.h5py: 465 tensor([[461., 462., 463., 464., 465.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([466.], device='cuda:0')
data.h5py: 466 tensor([[462., 463., 464., 465., 466.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([467.], device='cuda:0')
data.h5py: 467 tensor([[463., 464., 465., 466., 467.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([468.], device='cuda:0')
data.h5py: 468 tensor([[468., 468., 468., 468., 468.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([469.], device='cuda:0')
data.h5py: 469 tensor([[468., 468., 468., 468., 469.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([470.], device='cuda:0')
data.h5py: 470 tensor([[468., 468., 468., 469., 470.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([471.], device='cuda:0')
data.h5py: 471 tensor([[468., 468., 469., 470., 471.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([472.], device='cuda:0')
data.h5py: 472 tensor([[468., 469., 470., 471., 472.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([473.], device='cuda:0')
data.h5py: 473 tensor([[469., 470., 471., 472., 473.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([474.], device='cuda:0')
data.h5py: 474 tensor([[470., 471., 472., 473., 474.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([475.], device='cuda:0')
data.h5py: 475 tensor([[471., 472., 473., 474., 475.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([476.], device='cuda:0')
data.h5py: 476 tensor([[472., 473., 474., 475., 476.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([477.], device='cuda:0')
data.h5py: 477 tensor([[473., 474., 475., 476., 477.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([478.], device='cuda:0')
data.h5py: 478 tensor([[474., 475., 476., 477., 478.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([479.], device='cuda:0')
data.h5py: 479 tensor([[475., 476., 477., 478., 479.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([480.], device='cuda:0')
data.h5py: 480 tensor([[476., 477., 478., 479., 480.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([481.], device='cuda:0')
data.h5py: 481 tensor([[477., 478., 479., 480., 481.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([482.], device='cuda:0')
data.h5py: 482 tensor([[478., 479., 480., 481., 482.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([483.], device='cuda:0')
data.h5py: 483 tensor([[479., 480., 481., 482., 483.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([484.], device='cuda:0')
data.h5py: 484 tensor([[480., 481., 482., 483., 484.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([485.], device='cuda:0')
data.h5py: 485 tensor([[481., 482., 483., 484., 485.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([486.], device='cuda:0')
data.h5py: 486 tensor([[486., 486., 486., 486., 486.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([487.], device='cuda:0')
data.h5py: 487 tensor([[486., 486., 486., 486., 487.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([488.], device='cuda:0')
data.h5py: 488 tensor([[486., 486., 486., 487., 488.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([489.], device='cuda:0')
data.h5py: 489 tensor([[486., 486., 487., 488., 489.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([490.], device='cuda:0')
data.h5py: 490 tensor([[486., 487., 488., 489., 490.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([491.], device='cuda:0')
data.h5py: 491 tensor([[487., 488., 489., 490., 491.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([492.], device='cuda:0')
data.h5py: 492 tensor([[488., 489., 490., 491., 492.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([493.], device='cuda:0')
data.h5py: 493 tensor([[489., 490., 491., 492., 493.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([494.], device='cuda:0')
data.h5py: 494 tensor([[490., 491., 492., 493., 494.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([495.], device='cuda:0')
data.h5py: 495 tensor([[491., 492., 493., 494., 495.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([496.], device='cuda:0')
data.h5py: 496 tensor([[492., 493., 494., 495., 496.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([497.], device='cuda:0')
data.h5py: 497 tensor([[493., 494., 495., 496., 497.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([498.], device='cuda:0')
data.h5py: 498 tensor([[494., 495., 496., 497., 498.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([499.], device='cuda:0')
data.h5py: 499 tensor([[495., 496., 497., 498., 499.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([500.], device='cuda:0')
data.h5py: 500 tensor([[500., 500., 500., 500., 500.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([501.], device='cuda:0')
data.h5py: 501 tensor([[500., 500., 500., 500., 501.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([502.], device='cuda:0')
data.h5py: 502 tensor([[500., 500., 500., 501., 502.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([503.], device='cuda:0')
data.h5py: 503 tensor([[500., 500., 501., 502., 503.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([504.], device='cuda:0')
data.h5py: 504 tensor([[500., 501., 502., 503., 504.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([505.], device='cuda:0')
data.h5py: 505 tensor([[501., 502., 503., 504., 505.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([506.], device='cuda:0')
data.h5py: 506 tensor([[502., 503., 504., 505., 506.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([507.], device='cuda:0')
data.h5py: 507 tensor([[503., 504., 505., 506., 507.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([508.], device='cuda:0')
data.h5py: 508 tensor([[504., 505., 506., 507., 508.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([509.], device='cuda:0')
data.h5py: 509 tensor([[505., 506., 507., 508., 509.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([510.], device='cuda:0')
data.h5py: 510 tensor([[510., 510., 510., 510., 510.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([511.], device='cuda:0')
data.h5py: 511 tensor([[510., 510., 510., 510., 511.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([512.], device='cuda:0')
data.h5py: 512 tensor([[510., 510., 510., 511., 512.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([513.], device='cuda:0')
data.h5py: 513 tensor([[510., 510., 511., 512., 513.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([514.], device='cuda:0')
data.h5py: 514 tensor([[510., 511., 512., 513., 514.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([515.], device='cuda:0')
data.h5py: 515 tensor([[511., 512., 513., 514., 515.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([516.], device='cuda:0')
data.h5py: 516 tensor([[512., 513., 514., 515., 516.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([517.], device='cuda:0')
data.h5py: 517 tensor([[513., 514., 515., 516., 517.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([518.], device='cuda:0')
data.h5py: 518 tensor([[514., 515., 516., 517., 518.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([519.], device='cuda:0')
data.h5py: 519 tensor([[515., 516., 517., 518., 519.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([520.], device='cuda:0')
data.h5py: 520 tensor([[516., 517., 518., 519., 520.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([521.], device='cuda:0')
data.h5py: 521 tensor([[517., 518., 519., 520., 521.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([522.], device='cuda:0')
data.h5py: 522 tensor([[518., 519., 520., 521., 522.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([523.], device='cuda:0')
data.h5py: 523 tensor([[519., 520., 521., 522., 523.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([524.], device='cuda:0')
data.h5py: 524 tensor([[520., 521., 522., 523., 524.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([525.], device='cuda:0')
data.h5py: 525 tensor([[521., 522., 523., 524., 525.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([526.], device='cuda:0')
data.h5py: 526 tensor([[522., 523., 524., 525., 526.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([527.], device='cuda:0')
data.h5py: 527 tensor([[523., 524., 525., 526., 527.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([528.], device='cuda:0')
data.h5py: 528 tensor([[528., 528., 528., 528., 528.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([529.], device='cuda:0')
data.h5py: 529 tensor([[528., 528., 528., 528., 529.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([530.], device='cuda:0')
data.h5py: 530 tensor([[528., 528., 528., 529., 530.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([531.], device='cuda:0')
data.h5py: 531 tensor([[528., 528., 529., 530., 531.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([532.], device='cuda:0')
data.h5py: 532 tensor([[528., 529., 530., 531., 532.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([533.], device='cuda:0')
data.h5py: 533 tensor([[529., 530., 531., 532., 533.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([534.], device='cuda:0')
data.h5py: 534 tensor([[530., 531., 532., 533., 534.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([535.], device='cuda:0')
data.h5py: 535 tensor([[531., 532., 533., 534., 535.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([536.], device='cuda:0')
data.h5py: 536 tensor([[532., 533., 534., 535., 536.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([537.], device='cuda:0')
data.h5py: 537 tensor([[533., 534., 535., 536., 537.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([538.], device='cuda:0')
data.h5py: 538 tensor([[534., 535., 536., 537., 538.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([539.], device='cuda:0')
data.h5py: 539 tensor([[535., 536., 537., 538., 539.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([540.], device='cuda:0')
data.h5py: 540 tensor([[536., 537., 538., 539., 540.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([541.], device='cuda:0')
data.h5py: 541 tensor([[541., 541., 541., 541., 541.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([542.], device='cuda:0')
data.h5py: 542 tensor([[541., 541., 541., 541., 542.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([543.], device='cuda:0')
data.h5py: 543 tensor([[541., 541., 541., 542., 543.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([544.], device='cuda:0')
data.h5py: 544 tensor([[541., 541., 542., 543., 544.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([545.], device='cuda:0')
data.h5py: 545 tensor([[541., 542., 543., 544., 545.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([546.], device='cuda:0')
data.h5py: 546 tensor([[542., 543., 544., 545., 546.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([547.], device='cuda:0')
data.h5py: 547 tensor([[543., 544., 545., 546., 547.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([548.], device='cuda:0')
data.h5py: 548 tensor([[544., 545., 546., 547., 548.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([549.], device='cuda:0')
data.h5py: 549 tensor([[545., 546., 547., 548., 549.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([550.], device='cuda:0')
data.h5py: 550 tensor([[546., 547., 548., 549., 550.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([551.], device='cuda:0')
data.h5py: 551 tensor([[547., 548., 549., 550., 551.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([552.], device='cuda:0')
data.h5py: 552 tensor([[548., 549., 550., 551., 552.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([553.], device='cuda:0')
data.h5py: 553 tensor([[549., 550., 551., 552., 553.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([554.], device='cuda:0')
data.h5py: 554 tensor([[550., 551., 552., 553., 554.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([555.], device='cuda:0')
data.h5py: 555 tensor([[555., 555., 555., 555., 555.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([556.], device='cuda:0')
data.h5py: 556 tensor([[555., 555., 555., 555., 556.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([557.], device='cuda:0')
data.h5py: 557 tensor([[555., 555., 555., 556., 557.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([558.], device='cuda:0')
data.h5py: 558 tensor([[555., 555., 556., 557., 558.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([559.], device='cuda:0')
data.h5py: 559 tensor([[555., 556., 557., 558., 559.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([560.], device='cuda:0')
data.h5py: 560 tensor([[556., 557., 558., 559., 560.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([561.], device='cuda:0')
data.h5py: 561 tensor([[557., 558., 559., 560., 561.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([562.], device='cuda:0')
data.h5py: 562 tensor([[558., 559., 560., 561., 562.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([563.], device='cuda:0')
data.h5py: 563 tensor([[559., 560., 561., 562., 563.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([564.], device='cuda:0')
data.h5py: 564 tensor([[560., 561., 562., 563., 564.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([565.], device='cuda:0')
data.h5py: 565 tensor([[561., 562., 563., 564., 565.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([566.], device='cuda:0')
data.h5py: 566 tensor([[562., 563., 564., 565., 566.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([567.], device='cuda:0')
data.h5py: 567 tensor([[563., 564., 565., 566., 567.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([568.], device='cuda:0')
data.h5py: 568 tensor([[564., 565., 566., 567., 568.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([569.], device='cuda:0')
data.h5py: 569 tensor([[565., 566., 567., 568., 569.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([570.], device='cuda:0')
data.h5py: 570 tensor([[566., 567., 568., 569., 570.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([571.], device='cuda:0')
data.h5py: 571 tensor([[567., 568., 569., 570., 571.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([572.], device='cuda:0')
data.h5py: 572 tensor([[568., 569., 570., 571., 572.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([573.], device='cuda:0')
data.h5py: 573 tensor([[573., 573., 573., 573., 573.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([574.], device='cuda:0')
data.h5py: 574 tensor([[573., 573., 573., 573., 574.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([575.], device='cuda:0')
data.h5py: 575 tensor([[573., 573., 573., 574., 575.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([576.], device='cuda:0')
data.h5py: 576 tensor([[573., 573., 574., 575., 576.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([577.], device='cuda:0')
data.h5py: 577 tensor([[573., 574., 575., 576., 577.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([578.], device='cuda:0')
data.h5py: 578 tensor([[574., 575., 576., 577., 578.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([579.], device='cuda:0')
data.h5py: 579 tensor([[575., 576., 577., 578., 579.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([580.], device='cuda:0')
data.h5py: 580 tensor([[576., 577., 578., 579., 580.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([581.], device='cuda:0')
data.h5py: 581 tensor([[577., 578., 579., 580., 581.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([582.], device='cuda:0')
data.h5py: 582 tensor([[578., 579., 580., 581., 582.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([583.], device='cuda:0')
data.h5py: 583 tensor([[579., 580., 581., 582., 583.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([584.], device='cuda:0')
data.h5py: 584 tensor([[580., 581., 582., 583., 584.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([585.], device='cuda:0')
data.h5py: 585 tensor([[581., 582., 583., 584., 585.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([586.], device='cuda:0')
data.h5py: 586 tensor([[582., 583., 584., 585., 586.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([587.], device='cuda:0')
data.h5py: 587 tensor([[583., 584., 585., 586., 587.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([588.], device='cuda:0')
data.h5py: 588 tensor([[584., 585., 586., 587., 588.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([589.], device='cuda:0')
data.h5py: 589 tensor([[589., 589., 589., 589., 589.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([590.], device='cuda:0')
data.h5py: 590 tensor([[589., 589., 589., 589., 590.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([591.], device='cuda:0')
data.h5py: 591 tensor([[589., 589., 589., 590., 591.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([592.], device='cuda:0')
data.h5py: 592 tensor([[589., 589., 590., 591., 592.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([593.], device='cuda:0')
data.h5py: 593 tensor([[589., 590., 591., 592., 593.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([594.], device='cuda:0')
data.h5py: 594 tensor([[590., 591., 592., 593., 594.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([595.], device='cuda:0')
data.h5py: 595 tensor([[591., 592., 593., 594., 595.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([596.], device='cuda:0')
data.h5py: 596 tensor([[592., 593., 594., 595., 596.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([597.], device='cuda:0')
data.h5py: 597 tensor([[593., 594., 595., 596., 597.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([598.], device='cuda:0')
data.h5py: 598 tensor([[594., 595., 596., 597., 598.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([599.], device='cuda:0')
data.h5py: 599 tensor([[595., 596., 597., 598., 599.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([600.], device='cuda:0')
data.h5py: 600 tensor([[596., 597., 598., 599., 600.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([601.], device='cuda:0')
data.h5py: 601 tensor([[601., 601., 601., 601., 601.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([602.], device='cuda:0')
data.h5py: 602 tensor([[601., 601., 601., 601., 602.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([603.], device='cuda:0')
data.h5py: 603 tensor([[601., 601., 601., 602., 603.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([604.], device='cuda:0')
data.h5py: 604 tensor([[601., 601., 602., 603., 604.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([605.], device='cuda:0')
data.h5py: 605 tensor([[601., 602., 603., 604., 605.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([606.], device='cuda:0')
data.h5py: 606 tensor([[602., 603., 604., 605., 606.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([607.], device='cuda:0')
data.h5py: 607 tensor([[603., 604., 605., 606., 607.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([608.], device='cuda:0')
data.h5py: 608 tensor([[604., 605., 606., 607., 608.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([609.], device='cuda:0')
data.h5py: 609 tensor([[605., 606., 607., 608., 609.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([610.], device='cuda:0')
data.h5py: 610 tensor([[606., 607., 608., 609., 610.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([611.], device='cuda:0')
data.h5py: 611 tensor([[607., 608., 609., 610., 611.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([612.], device='cuda:0')
data.h5py: 612 tensor([[608., 609., 610., 611., 612.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([613.], device='cuda:0')
data.h5py: 613 tensor([[609., 610., 611., 612., 613.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([614.], device='cuda:0')
data.h5py: 614 tensor([[610., 611., 612., 613., 614.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([615.], device='cuda:0')
data.h5py: 615 tensor([[615., 615., 615., 615., 615.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([616.], device='cuda:0')
data.h5py: 616 tensor([[615., 615., 615., 615., 616.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([617.], device='cuda:0')
data.h5py: 617 tensor([[615., 615., 615., 616., 617.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([618.], device='cuda:0')
data.h5py: 618 tensor([[615., 615., 616., 617., 618.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([619.], device='cuda:0')
data.h5py: 619 tensor([[615., 616., 617., 618., 619.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([620.], device='cuda:0')
data.h5py: 620 tensor([[616., 617., 618., 619., 620.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([621.], device='cuda:0')
data.h5py: 621 tensor([[617., 618., 619., 620., 621.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([622.], device='cuda:0')
data.h5py: 622 tensor([[618., 619., 620., 621., 622.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([623.], device='cuda:0')
data.h5py: 623 tensor([[619., 620., 621., 622., 623.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([624.], device='cuda:0')
data.h5py: 624 tensor([[620., 621., 622., 623., 624.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([625.], device='cuda:0')
data.h5py: 625 tensor([[621., 622., 623., 624., 625.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([626.], device='cuda:0')
data.h5py: 626 tensor([[622., 623., 624., 625., 626.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([627.], device='cuda:0')
data.h5py: 627 tensor([[623., 624., 625., 626., 627.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([628.], device='cuda:0')
data.h5py: 628 tensor([[624., 625., 626., 627., 628.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([629.], device='cuda:0')
data.h5py: 629 tensor([[625., 626., 627., 628., 629.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([630.], device='cuda:0')
data.h5py: 630 tensor([[626., 627., 628., 629., 630.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([631.], device='cuda:0')
data.h5py: 631 tensor([[631., 631., 631., 631., 631.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([632.], device='cuda:0')
data.h5py: 632 tensor([[631., 631., 631., 631., 632.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([633.], device='cuda:0')
data.h5py: 633 tensor([[631., 631., 631., 632., 633.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([634.], device='cuda:0')
data.h5py: 634 tensor([[631., 631., 632., 633., 634.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([635.], device='cuda:0')
data.h5py: 635 tensor([[631., 632., 633., 634., 635.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([636.], device='cuda:0')
data.h5py: 636 tensor([[632., 633., 634., 635., 636.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([637.], device='cuda:0')
data.h5py: 637 tensor([[633., 634., 635., 636., 637.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([638.], device='cuda:0')
data.h5py: 638 tensor([[634., 635., 636., 637., 638.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([639.], device='cuda:0')
data.h5py: 639 tensor([[635., 636., 637., 638., 639.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([640.], device='cuda:0')
data.h5py: 640 tensor([[636., 637., 638., 639., 640.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([641.], device='cuda:0')
data.h5py: 641 tensor([[637., 638., 639., 640., 641.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([642.], device='cuda:0')
data.h5py: 642 tensor([[638., 639., 640., 641., 642.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([643.], device='cuda:0')
data.h5py: 643 tensor([[639., 640., 641., 642., 643.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([644.], device='cuda:0')
data.h5py: 644 tensor([[640., 641., 642., 643., 644.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([645.], device='cuda:0')
data.h5py: 645 tensor([[641., 642., 643., 644., 645.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([646.], device='cuda:0')
data.h5py: 646 tensor([[642., 643., 644., 645., 646.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([647.], device='cuda:0')
data.h5py: 647 tensor([[643., 644., 645., 646., 647.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([648.], device='cuda:0')
data.h5py: 648 tensor([[644., 645., 646., 647., 648.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([649.], device='cuda:0')
data.h5py: 649 tensor([[645., 646., 647., 648., 649.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([650.], device='cuda:0')
data.h5py: 650 tensor([[646., 647., 648., 649., 650.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([651.], device='cuda:0')
data.h5py: 651 tensor([[651., 651., 651., 651., 651.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([652.], device='cuda:0')
data.h5py: 652 tensor([[651., 651., 651., 651., 652.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([653.], device='cuda:0')
data.h5py: 653 tensor([[651., 651., 651., 652., 653.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([654.], device='cuda:0')
data.h5py: 654 tensor([[651., 651., 652., 653., 654.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([655.], device='cuda:0')
data.h5py: 655 tensor([[651., 652., 653., 654., 655.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([656.], device='cuda:0')
data.h5py: 656 tensor([[652., 653., 654., 655., 656.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([657.], device='cuda:0')
data.h5py: 657 tensor([[653., 654., 655., 656., 657.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([658.], device='cuda:0')
data.h5py: 658 tensor([[654., 655., 656., 657., 658.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([659.], device='cuda:0')
data.h5py: 659 tensor([[655., 656., 657., 658., 659.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([660.], device='cuda:0')
data.h5py: 660 tensor([[656., 657., 658., 659., 660.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([661.], device='cuda:0')
data.h5py: 661 tensor([[657., 658., 659., 660., 661.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([662.], device='cuda:0')
data.h5py: 662 tensor([[658., 659., 660., 661., 662.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([663.], device='cuda:0')
data.h5py: 663 tensor([[659., 660., 661., 662., 663.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([664.], device='cuda:0')
data.h5py: 664 tensor([[660., 661., 662., 663., 664.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([665.], device='cuda:0')
data.h5py: 665 tensor([[661., 662., 663., 664., 665.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([666.], device='cuda:0')
data.h5py: 666 tensor([[662., 663., 664., 665., 666.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([667.], device='cuda:0')
data.h5py: 667 tensor([[663., 664., 665., 666., 667.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([668.], device='cuda:0')
data.h5py: 668 tensor([[664., 665., 666., 667., 668.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([669.], device='cuda:0')
data.h5py: 669 tensor([[669., 669., 669., 669., 669.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([670.], device='cuda:0')
data.h5py: 670 tensor([[669., 669., 669., 669., 670.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([671.], device='cuda:0')
data.h5py: 671 tensor([[669., 669., 669., 670., 671.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([672.], device='cuda:0')
data.h5py: 672 tensor([[669., 669., 670., 671., 672.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([673.], device='cuda:0')
data.h5py: 673 tensor([[669., 670., 671., 672., 673.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([674.], device='cuda:0')
data.h5py: 674 tensor([[670., 671., 672., 673., 674.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([675.], device='cuda:0')
data.h5py: 675 tensor([[671., 672., 673., 674., 675.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([676.], device='cuda:0')
data.h5py: 676 tensor([[672., 673., 674., 675., 676.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([677.], device='cuda:0')
data.h5py: 677 tensor([[673., 674., 675., 676., 677.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([678.], device='cuda:0')
data.h5py: 678 tensor([[674., 675., 676., 677., 678.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([679.], device='cuda:0')
data.h5py: 679 tensor([[675., 676., 677., 678., 679.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([680.], device='cuda:0')
data.h5py: 680 tensor([[676., 677., 678., 679., 680.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([681.], device='cuda:0')
data.h5py: 681 tensor([[677., 678., 679., 680., 681.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([682.], device='cuda:0')
data.h5py: 682 tensor([[678., 679., 680., 681., 682.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([683.], device='cuda:0')
data.h5py: 683 tensor([[679., 680., 681., 682., 683.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([684.], device='cuda:0')
data.h5py: 684 tensor([[680., 681., 682., 683., 684.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([685.], device='cuda:0')
data.h5py: 685 tensor([[685., 685., 685., 685., 685.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([686.], device='cuda:0')
data.h5py: 686 tensor([[685., 685., 685., 685., 686.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([687.], device='cuda:0')
data.h5py: 687 tensor([[685., 685., 685., 686., 687.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([688.], device='cuda:0')
data.h5py: 688 tensor([[685., 685., 686., 687., 688.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([689.], device='cuda:0')
data.h5py: 689 tensor([[685., 686., 687., 688., 689.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([690.], device='cuda:0')
data.h5py: 690 tensor([[686., 687., 688., 689., 690.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([691.], device='cuda:0')
data.h5py: 691 tensor([[687., 688., 689., 690., 691.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([692.], device='cuda:0')
data.h5py: 692 tensor([[688., 689., 690., 691., 692.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([693.], device='cuda:0')
data.h5py: 693 tensor([[689., 690., 691., 692., 693.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([694.], device='cuda:0')
data.h5py: 694 tensor([[690., 691., 692., 693., 694.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([695.], device='cuda:0')
data.h5py: 695 tensor([[691., 692., 693., 694., 695.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([696.], device='cuda:0')
data.h5py: 696 tensor([[692., 693., 694., 695., 696.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([697.], device='cuda:0')
data.h5py: 697 tensor([[693., 694., 695., 696., 697.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([698.], device='cuda:0')
data.h5py: 698 tensor([[694., 695., 696., 697., 698.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([699.], device='cuda:0')
data.h5py: 699 tensor([[695., 696., 697., 698., 699.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([700.], device='cuda:0')
data.h5py: 700 tensor([[696., 697., 698., 699., 700.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([701.], device='cuda:0')
data.h5py: 701 tensor([[697., 698., 699., 700., 701.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([702.], device='cuda:0')
data.h5py: 702 tensor([[698., 699., 700., 701., 702.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([703.], device='cuda:0')
data.h5py: 703 tensor([[699., 700., 701., 702., 703.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([704.], device='cuda:0')
data.h5py: 704 tensor([[704., 704., 704., 704., 704.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([705.], device='cuda:0')
data.h5py: 705 tensor([[704., 704., 704., 704., 705.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([706.], device='cuda:0')
data.h5py: 706 tensor([[704., 704., 704., 705., 706.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([707.], device='cuda:0')
data.h5py: 707 tensor([[704., 704., 705., 706., 707.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([708.], device='cuda:0')
data.h5py: 708 tensor([[704., 705., 706., 707., 708.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([709.], device='cuda:0')
data.h5py: 709 tensor([[705., 706., 707., 708., 709.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([710.], device='cuda:0')
data.h5py: 710 tensor([[706., 707., 708., 709., 710.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([711.], device='cuda:0')
data.h5py: 711 tensor([[707., 708., 709., 710., 711.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([712.], device='cuda:0')
data.h5py: 712 tensor([[708., 709., 710., 711., 712.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([713.], device='cuda:0')
data.h5py: 713 tensor([[709., 710., 711., 712., 713.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([714.], device='cuda:0')
data.h5py: 714 tensor([[710., 711., 712., 713., 714.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([715.], device='cuda:0')
data.h5py: 715 tensor([[711., 712., 713., 714., 715.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([716.], device='cuda:0')
data.h5py: 716 tensor([[712., 713., 714., 715., 716.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([717.], device='cuda:0')
data.h5py: 717 tensor([[713., 714., 715., 716., 717.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([718.], device='cuda:0')
data.h5py: 718 tensor([[714., 715., 716., 717., 718.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([719.], device='cuda:0')
data.h5py: 719 tensor([[715., 716., 717., 718., 719.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([720.], device='cuda:0')
data.h5py: 720 tensor([[716., 717., 718., 719., 720.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([721.], device='cuda:0')
data.h5py: 721 tensor([[721., 721., 721., 721., 721.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([722.], device='cuda:0')
data.h5py: 722 tensor([[721., 721., 721., 721., 722.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([723.], device='cuda:0')
data.h5py: 723 tensor([[721., 721., 721., 722., 723.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([724.], device='cuda:0')
data.h5py: 724 tensor([[721., 721., 722., 723., 724.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([725.], device='cuda:0')
data.h5py: 725 tensor([[721., 722., 723., 724., 725.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([726.], device='cuda:0')
data.h5py: 726 tensor([[722., 723., 724., 725., 726.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([727.], device='cuda:0')
data.h5py: 727 tensor([[723., 724., 725., 726., 727.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([728.], device='cuda:0')
data.h5py: 728 tensor([[724., 725., 726., 727., 728.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([729.], device='cuda:0')
data.h5py: 729 tensor([[725., 726., 727., 728., 729.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([730.], device='cuda:0')
data.h5py: 730 tensor([[726., 727., 728., 729., 730.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([731.], device='cuda:0')
data.h5py: 731 tensor([[727., 728., 729., 730., 731.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([732.], device='cuda:0')
data.h5py: 732 tensor([[728., 729., 730., 731., 732.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([733.], device='cuda:0')
data.h5py: 733 tensor([[729., 730., 731., 732., 733.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([734.], device='cuda:0')
data.h5py: 734 tensor([[730., 731., 732., 733., 734.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([735.], device='cuda:0')
data.h5py: 735 tensor([[735., 735., 735., 735., 735.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([736.], device='cuda:0')
data.h5py: 736 tensor([[735., 735., 735., 735., 736.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([737.], device='cuda:0')
data.h5py: 737 tensor([[735., 735., 735., 736., 737.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([738.], device='cuda:0')
data.h5py: 738 tensor([[735., 735., 736., 737., 738.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([739.], device='cuda:0')
data.h5py: 739 tensor([[735., 736., 737., 738., 739.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([740.], device='cuda:0')
data.h5py: 740 tensor([[736., 737., 738., 739., 740.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([741.], device='cuda:0')
data.h5py: 741 tensor([[737., 738., 739., 740., 741.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([742.], device='cuda:0')
data.h5py: 742 tensor([[738., 739., 740., 741., 742.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([743.], device='cuda:0')
data.h5py: 743 tensor([[739., 740., 741., 742., 743.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([744.], device='cuda:0')
data.h5py: 744 tensor([[740., 741., 742., 743., 744.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([745.], device='cuda:0')
data.h5py: 745 tensor([[741., 742., 743., 744., 745.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([746.], device='cuda:0')
data.h5py: 746 tensor([[742., 743., 744., 745., 746.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([747.], device='cuda:0')
data.h5py: 747 tensor([[743., 744., 745., 746., 747.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([748.], device='cuda:0')
data.h5py: 748 tensor([[744., 745., 746., 747., 748.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([749.], device='cuda:0')
data.h5py: 749 tensor([[745., 746., 747., 748., 749.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([750.], device='cuda:0')
data.h5py: 750 tensor([[746., 747., 748., 749., 750.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([751.], device='cuda:0')
data.h5py: 751 tensor([[747., 748., 749., 750., 751.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([752.], device='cuda:0')
data.h5py: 752 tensor([[748., 749., 750., 751., 752.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([753.], device='cuda:0')
data.h5py: 753 tensor([[749., 750., 751., 752., 753.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([754.], device='cuda:0')
data.h5py: 754 tensor([[750., 751., 752., 753., 754.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([755.], device='cuda:0')
data.h5py: 755 tensor([[755., 755., 755., 755., 755.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([756.], device='cuda:0')
data.h5py: 756 tensor([[755., 755., 755., 755., 756.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([757.], device='cuda:0')
data.h5py: 757 tensor([[755., 755., 755., 756., 757.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([758.], device='cuda:0')
data.h5py: 758 tensor([[755., 755., 756., 757., 758.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([759.], device='cuda:0')
data.h5py: 759 tensor([[755., 756., 757., 758., 759.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([760.], device='cuda:0')
data.h5py: 760 tensor([[756., 757., 758., 759., 760.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([761.], device='cuda:0')
data.h5py: 761 tensor([[757., 758., 759., 760., 761.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([762.], device='cuda:0')
data.h5py: 762 tensor([[758., 759., 760., 761., 762.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([763.], device='cuda:0')
data.h5py: 763 tensor([[759., 760., 761., 762., 763.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([764.], device='cuda:0')
data.h5py: 764 tensor([[760., 761., 762., 763., 764.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([765.], device='cuda:0')
data.h5py: 765 tensor([[765., 765., 765., 765., 765.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([766.], device='cuda:0')
data.h5py: 766 tensor([[765., 765., 765., 765., 766.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([767.], device='cuda:0')
data.h5py: 767 tensor([[765., 765., 765., 766., 767.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([768.], device='cuda:0')
data.h5py: 768 tensor([[765., 765., 766., 767., 768.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([769.], device='cuda:0')
data.h5py: 769 tensor([[765., 766., 767., 768., 769.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([770.], device='cuda:0')
data.h5py: 770 tensor([[766., 767., 768., 769., 770.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([771.], device='cuda:0')
data.h5py: 771 tensor([[767., 768., 769., 770., 771.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([772.], device='cuda:0')
data.h5py: 772 tensor([[768., 769., 770., 771., 772.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([773.], device='cuda:0')
data.h5py: 773 tensor([[769., 770., 771., 772., 773.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([774.], device='cuda:0')
data.h5py: 774 tensor([[770., 771., 772., 773., 774.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([775.], device='cuda:0')
data.h5py: 775 tensor([[771., 772., 773., 774., 775.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([776.], device='cuda:0')
data.h5py: 776 tensor([[772., 773., 774., 775., 776.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([777.], device='cuda:0')
data.h5py: 777 tensor([[773., 774., 775., 776., 777.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([778.], device='cuda:0')
data.h5py: 778 tensor([[774., 775., 776., 777., 778.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([779.], device='cuda:0')
data.h5py: 779 tensor([[779., 779., 779., 779., 779.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([780.], device='cuda:0')
data.h5py: 780 tensor([[779., 779., 779., 779., 780.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([781.], device='cuda:0')
data.h5py: 781 tensor([[779., 779., 779., 780., 781.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([782.], device='cuda:0')
data.h5py: 782 tensor([[779., 779., 780., 781., 782.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([783.], device='cuda:0')
data.h5py: 783 tensor([[779., 780., 781., 782., 783.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([784.], device='cuda:0')
data.h5py: 784 tensor([[780., 781., 782., 783., 784.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([785.], device='cuda:0')
data.h5py: 785 tensor([[781., 782., 783., 784., 785.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([786.], device='cuda:0')
data.h5py: 786 tensor([[782., 783., 784., 785., 786.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([787.], device='cuda:0')
data.h5py: 787 tensor([[783., 784., 785., 786., 787.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([788.], device='cuda:0')
data.h5py: 788 tensor([[784., 785., 786., 787., 788.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([789.], device='cuda:0')
data.h5py: 789 tensor([[785., 786., 787., 788., 789.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([790.], device='cuda:0')
data.h5py: 790 tensor([[786., 787., 788., 789., 790.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([791.], device='cuda:0')
data.h5py: 791 tensor([[787., 788., 789., 790., 791.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([792.], device='cuda:0')
data.h5py: 792 tensor([[788., 789., 790., 791., 792.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([793.], device='cuda:0')
data.h5py: 793 tensor([[789., 790., 791., 792., 793.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([794.], device='cuda:0')
data.h5py: 794 tensor([[790., 791., 792., 793., 794.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([795.], device='cuda:0')
data.h5py: 795 tensor([[791., 792., 793., 794., 795.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([796.], device='cuda:0')
data.h5py: 796 tensor([[792., 793., 794., 795., 796.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([797.], device='cuda:0')
data.h5py: 797 tensor([[793., 794., 795., 796., 797.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([798.], device='cuda:0')
data.h5py: 798 tensor([[798., 798., 798., 798., 798.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([799.], device='cuda:0')
data.h5py: 799 tensor([[798., 798., 798., 798., 799.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([800.], device='cuda:0')
data.h5py: 800 tensor([[798., 798., 798., 799., 800.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([801.], device='cuda:0')
data.h5py: 801 tensor([[798., 798., 799., 800., 801.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([802.], device='cuda:0')
data.h5py: 802 tensor([[798., 799., 800., 801., 802.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([803.], device='cuda:0')
data.h5py: 803 tensor([[799., 800., 801., 802., 803.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([804.], device='cuda:0')
data.h5py: 804 tensor([[800., 801., 802., 803., 804.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([805.], device='cuda:0')
data.h5py: 805 tensor([[801., 802., 803., 804., 805.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([806.], device='cuda:0')
data.h5py: 806 tensor([[802., 803., 804., 805., 806.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([807.], device='cuda:0')
data.h5py: 807 tensor([[803., 804., 805., 806., 807.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([808.], device='cuda:0')
data.h5py: 808 tensor([[804., 805., 806., 807., 808.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([809.], device='cuda:0')
data.h5py: 809 tensor([[805., 806., 807., 808., 809.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([810.], device='cuda:0')
data.h5py: 810 tensor([[806., 807., 808., 809., 810.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([811.], device='cuda:0')
data.h5py: 811 tensor([[807., 808., 809., 810., 811.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([812.], device='cuda:0')
data.h5py: 812 tensor([[808., 809., 810., 811., 812.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([813.], device='cuda:0')
data.h5py: 813 tensor([[813., 813., 813., 813., 813.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([814.], device='cuda:0')
data.h5py: 814 tensor([[813., 813., 813., 813., 814.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([815.], device='cuda:0')
data.h5py: 815 tensor([[813., 813., 813., 814., 815.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([816.], device='cuda:0')
data.h5py: 816 tensor([[813., 813., 814., 815., 816.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([817.], device='cuda:0')
data.h5py: 817 tensor([[813., 814., 815., 816., 817.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([818.], device='cuda:0')
data.h5py: 818 tensor([[814., 815., 816., 817., 818.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([819.], device='cuda:0')
data.h5py: 819 tensor([[815., 816., 817., 818., 819.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([820.], device='cuda:0')
data.h5py: 820 tensor([[816., 817., 818., 819., 820.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([821.], device='cuda:0')
data.h5py: 821 tensor([[817., 818., 819., 820., 821.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([822.], device='cuda:0')
data.h5py: 822 tensor([[818., 819., 820., 821., 822.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([823.], device='cuda:0')
data.h5py: 823 tensor([[819., 820., 821., 822., 823.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([824.], device='cuda:0')
data.h5py: 824 tensor([[820., 821., 822., 823., 824.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([825.], device='cuda:0')
data.h5py: 825 tensor([[821., 822., 823., 824., 825.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([826.], device='cuda:0')
data.h5py: 826 tensor([[822., 823., 824., 825., 826.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([827.], device='cuda:0')
data.h5py: 827 tensor([[823., 824., 825., 826., 827.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([828.], device='cuda:0')
data.h5py: 828 tensor([[824., 825., 826., 827., 828.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([829.], device='cuda:0')
data.h5py: 829 tensor([[825., 826., 827., 828., 829.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([830.], device='cuda:0')
data.h5py: 830 tensor([[826., 827., 828., 829., 830.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([831.], device='cuda:0')
data.h5py: 831 tensor([[831., 831., 831., 831., 831.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([832.], device='cuda:0')
data.h5py: 832 tensor([[831., 831., 831., 831., 832.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([833.], device='cuda:0')
data.h5py: 833 tensor([[831., 831., 831., 832., 833.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([834.], device='cuda:0')
data.h5py: 834 tensor([[831., 831., 832., 833., 834.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([835.], device='cuda:0')
data.h5py: 835 tensor([[831., 832., 833., 834., 835.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([836.], device='cuda:0')
data.h5py: 836 tensor([[832., 833., 834., 835., 836.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([837.], device='cuda:0')
data.h5py: 837 tensor([[833., 834., 835., 836., 837.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([838.], device='cuda:0')
data.h5py: 838 tensor([[834., 835., 836., 837., 838.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([839.], device='cuda:0')
data.h5py: 839 tensor([[835., 836., 837., 838., 839.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([840.], device='cuda:0')
data.h5py: 840 tensor([[836., 837., 838., 839., 840.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([841.], device='cuda:0')
data.h5py: 841 tensor([[837., 838., 839., 840., 841.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([842.], device='cuda:0')
data.h5py: 842 tensor([[842., 842., 842., 842., 842.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([843.], device='cuda:0')
data.h5py: 843 tensor([[842., 842., 842., 842., 843.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([844.], device='cuda:0')
data.h5py: 844 tensor([[842., 842., 842., 843., 844.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([845.], device='cuda:0')
data.h5py: 845 tensor([[842., 842., 843., 844., 845.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([846.], device='cuda:0')
data.h5py: 846 tensor([[842., 843., 844., 845., 846.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([847.], device='cuda:0')
data.h5py: 847 tensor([[843., 844., 845., 846., 847.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([848.], device='cuda:0')
data.h5py: 848 tensor([[844., 845., 846., 847., 848.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([849.], device='cuda:0')
data.h5py: 849 tensor([[845., 846., 847., 848., 849.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([850.], device='cuda:0')
data.h5py: 850 tensor([[846., 847., 848., 849., 850.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([851.], device='cuda:0')
data.h5py: 851 tensor([[847., 848., 849., 850., 851.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([852.], device='cuda:0')
data.h5py: 852 tensor([[848., 849., 850., 851., 852.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([853.], device='cuda:0')
data.h5py: 853 tensor([[849., 850., 851., 852., 853.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([854.], device='cuda:0')
data.h5py: 854 tensor([[850., 851., 852., 853., 854.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([855.], device='cuda:0')
data.h5py: 855 tensor([[851., 852., 853., 854., 855.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([856.], device='cuda:0')
data.h5py: 856 tensor([[852., 853., 854., 855., 856.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([857.], device='cuda:0')
data.h5py: 857 tensor([[853., 854., 855., 856., 857.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([858.], device='cuda:0')
data.h5py: 858 tensor([[858., 858., 858., 858., 858.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([859.], device='cuda:0')
data.h5py: 859 tensor([[858., 858., 858., 858., 859.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([860.], device='cuda:0')
data.h5py: 860 tensor([[858., 858., 858., 859., 860.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([861.], device='cuda:0')
data.h5py: 861 tensor([[858., 858., 859., 860., 861.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([862.], device='cuda:0')
data.h5py: 862 tensor([[858., 859., 860., 861., 862.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([863.], device='cuda:0')
data.h5py: 863 tensor([[859., 860., 861., 862., 863.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([864.], device='cuda:0')
data.h5py: 864 tensor([[860., 861., 862., 863., 864.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([865.], device='cuda:0')
data.h5py: 865 tensor([[861., 862., 863., 864., 865.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([866.], device='cuda:0')
data.h5py: 866 tensor([[862., 863., 864., 865., 866.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([867.], device='cuda:0')
data.h5py: 867 tensor([[863., 864., 865., 866., 867.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([868.], device='cuda:0')
data.h5py: 868 tensor([[864., 865., 866., 867., 868.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([869.], device='cuda:0')
data.h5py: 869 tensor([[865., 866., 867., 868., 869.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([870.], device='cuda:0')
data.h5py: 870 tensor([[866., 867., 868., 869., 870.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([871.], device='cuda:0')
data.h5py: 871 tensor([[867., 868., 869., 870., 871.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([872.], device='cuda:0')
data.h5py: 872 tensor([[868., 869., 870., 871., 872.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([873.], device='cuda:0')
data.h5py: 873 tensor([[869., 870., 871., 872., 873.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([874.], device='cuda:0')
data.h5py: 874 tensor([[870., 871., 872., 873., 874.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([875.], device='cuda:0')
data.h5py: 875 tensor([[871., 872., 873., 874., 875.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([876.], device='cuda:0')
data.h5py: 876 tensor([[872., 873., 874., 875., 876.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([877.], device='cuda:0')
data.h5py: 877 tensor([[877., 877., 877., 877., 877.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([878.], device='cuda:0')
data.h5py: 878 tensor([[877., 877., 877., 877., 878.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([879.], device='cuda:0')
data.h5py: 879 tensor([[877., 877., 877., 878., 879.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([880.], device='cuda:0')
data.h5py: 880 tensor([[877., 877., 878., 879., 880.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([881.], device='cuda:0')
data.h5py: 881 tensor([[877., 878., 879., 880., 881.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([882.], device='cuda:0')
data.h5py: 882 tensor([[878., 879., 880., 881., 882.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([883.], device='cuda:0')
data.h5py: 883 tensor([[879., 880., 881., 882., 883.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([884.], device='cuda:0')
data.h5py: 884 tensor([[880., 881., 882., 883., 884.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([885.], device='cuda:0')
data.h5py: 885 tensor([[881., 882., 883., 884., 885.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([886.], device='cuda:0')
data.h5py: 886 tensor([[882., 883., 884., 885., 886.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([887.], device='cuda:0')
data.h5py: 887 tensor([[883., 884., 885., 886., 887.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([888.], device='cuda:0')
data.h5py: 888 tensor([[884., 885., 886., 887., 888.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([889.], device='cuda:0')
data.h5py: 889 tensor([[885., 886., 887., 888., 889.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([890.], device='cuda:0')
data.h5py: 890 tensor([[890., 890., 890., 890., 890.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([891.], device='cuda:0')
data.h5py: 891 tensor([[890., 890., 890., 890., 891.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([892.], device='cuda:0')
data.h5py: 892 tensor([[890., 890., 890., 891., 892.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([893.], device='cuda:0')
data.h5py: 893 tensor([[890., 890., 891., 892., 893.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([894.], device='cuda:0')
data.h5py: 894 tensor([[890., 891., 892., 893., 894.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([895.], device='cuda:0')
data.h5py: 895 tensor([[891., 892., 893., 894., 895.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([896.], device='cuda:0')
data.h5py: 896 tensor([[892., 893., 894., 895., 896.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([897.], device='cuda:0')
data.h5py: 897 tensor([[893., 894., 895., 896., 897.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([898.], device='cuda:0')
data.h5py: 898 tensor([[894., 895., 896., 897., 898.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([899.], device='cuda:0')
data.h5py: 899 tensor([[895., 896., 897., 898., 899.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([900.], device='cuda:0')
data.h5py: 900 tensor([[896., 897., 898., 899., 900.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([901.], device='cuda:0')
data.h5py: 901 tensor([[897., 898., 899., 900., 901.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([902.], device='cuda:0')
data.h5py: 902 tensor([[898., 899., 900., 901., 902.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([903.], device='cuda:0')
data.h5py: 903 tensor([[899., 900., 901., 902., 903.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([904.], device='cuda:0')
data.h5py: 904 tensor([[900., 901., 902., 903., 904.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([905.], device='cuda:0')
data.h5py: 905 tensor([[901., 902., 903., 904., 905.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([906.], device='cuda:0')
data.h5py: 906 tensor([[902., 903., 904., 905., 906.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([907.], device='cuda:0')
data.h5py: 907 tensor([[907., 907., 907., 907., 907.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([908.], device='cuda:0')
data.h5py: 908 tensor([[907., 907., 907., 907., 908.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([909.], device='cuda:0')
data.h5py: 909 tensor([[907., 907., 907., 908., 909.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([910.], device='cuda:0')
data.h5py: 910 tensor([[907., 907., 908., 909., 910.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([911.], device='cuda:0')
data.h5py: 911 tensor([[907., 908., 909., 910., 911.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([912.], device='cuda:0')
data.h5py: 912 tensor([[908., 909., 910., 911., 912.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([913.], device='cuda:0')
data.h5py: 913 tensor([[909., 910., 911., 912., 913.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([914.], device='cuda:0')
data.h5py: 914 tensor([[910., 911., 912., 913., 914.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([915.], device='cuda:0')
data.h5py: 915 tensor([[911., 912., 913., 914., 915.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([916.], device='cuda:0')
data.h5py: 916 tensor([[912., 913., 914., 915., 916.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([917.], device='cuda:0')
data.h5py: 917 tensor([[913., 914., 915., 916., 917.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([918.], device='cuda:0')
data.h5py: 918 tensor([[914., 915., 916., 917., 918.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([919.], device='cuda:0')
data.h5py: 919 tensor([[915., 916., 917., 918., 919.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([920.], device='cuda:0')
data.h5py: 920 tensor([[920., 920., 920., 920., 920.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([921.], device='cuda:0')
data.h5py: 921 tensor([[920., 920., 920., 920., 921.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([922.], device='cuda:0')
data.h5py: 922 tensor([[920., 920., 920., 921., 922.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([923.], device='cuda:0')
data.h5py: 923 tensor([[920., 920., 921., 922., 923.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([924.], device='cuda:0')
data.h5py: 924 tensor([[920., 921., 922., 923., 924.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([925.], device='cuda:0')
data.h5py: 925 tensor([[921., 922., 923., 924., 925.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([926.], device='cuda:0')
data.h5py: 926 tensor([[922., 923., 924., 925., 926.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([927.], device='cuda:0')
data.h5py: 927 tensor([[923., 924., 925., 926., 927.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([928.], device='cuda:0')
data.h5py: 928 tensor([[924., 925., 926., 927., 928.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([929.], device='cuda:0')
data.h5py: 929 tensor([[925., 926., 927., 928., 929.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([930.], device='cuda:0')
data.h5py: 930 tensor([[926., 927., 928., 929., 930.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([931.], device='cuda:0')
data.h5py: 931 tensor([[927., 928., 929., 930., 931.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([932.], device='cuda:0')
data.h5py: 932 tensor([[928., 929., 930., 931., 932.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([933.], device='cuda:0')
data.h5py: 933 tensor([[929., 930., 931., 932., 933.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([934.], device='cuda:0')
data.h5py: 934 tensor([[930., 931., 932., 933., 934.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([935.], device='cuda:0')
data.h5py: 935 tensor([[931., 932., 933., 934., 935.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([936.], device='cuda:0')
data.h5py: 936 tensor([[932., 933., 934., 935., 936.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([937.], device='cuda:0')
data.h5py: 937 tensor([[937., 937., 937., 937., 937.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([938.], device='cuda:0')
data.h5py: 938 tensor([[937., 937., 937., 937., 938.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([939.], device='cuda:0')
data.h5py: 939 tensor([[937., 937., 937., 938., 939.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([940.], device='cuda:0')
data.h5py: 940 tensor([[937., 937., 938., 939., 940.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([941.], device='cuda:0')
data.h5py: 941 tensor([[937., 938., 939., 940., 941.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([942.], device='cuda:0')
data.h5py: 942 tensor([[938., 939., 940., 941., 942.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([943.], device='cuda:0')
data.h5py: 943 tensor([[939., 940., 941., 942., 943.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([944.], device='cuda:0')
data.h5py: 944 tensor([[940., 941., 942., 943., 944.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([945.], device='cuda:0')
data.h5py: 945 tensor([[941., 942., 943., 944., 945.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([946.], device='cuda:0')
data.h5py: 946 tensor([[942., 943., 944., 945., 946.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([947.], device='cuda:0')
data.h5py: 947 tensor([[943., 944., 945., 946., 947.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([948.], device='cuda:0')
data.h5py: 948 tensor([[944., 945., 946., 947., 948.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([949.], device='cuda:0')
data.h5py: 949 tensor([[945., 946., 947., 948., 949.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([950.], device='cuda:0')
data.h5py: 950 tensor([[946., 947., 948., 949., 950.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([951.], device='cuda:0')
data.h5py: 951 tensor([[947., 948., 949., 950., 951.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([952.], device='cuda:0')
data.h5py: 952 tensor([[948., 949., 950., 951., 952.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([953.], device='cuda:0')
data.h5py: 953 tensor([[953., 953., 953., 953., 953.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([954.], device='cuda:0')
data.h5py: 954 tensor([[953., 953., 953., 953., 954.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([955.], device='cuda:0')
data.h5py: 955 tensor([[953., 953., 953., 954., 955.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([956.], device='cuda:0')
data.h5py: 956 tensor([[953., 953., 954., 955., 956.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([957.], device='cuda:0')
data.h5py: 957 tensor([[953., 954., 955., 956., 957.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([958.], device='cuda:0')
data.h5py: 958 tensor([[954., 955., 956., 957., 958.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([959.], device='cuda:0')
data.h5py: 959 tensor([[955., 956., 957., 958., 959.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([960.], device='cuda:0')
data.h5py: 960 tensor([[956., 957., 958., 959., 960.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([961.], device='cuda:0')
data.h5py: 961 tensor([[957., 958., 959., 960., 961.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([962.], device='cuda:0')
data.h5py: 962 tensor([[958., 959., 960., 961., 962.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([963.], device='cuda:0')
data.h5py: 963 tensor([[963., 963., 963., 963., 963.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([964.], device='cuda:0')
data.h5py: 964 tensor([[963., 963., 963., 963., 964.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([965.], device='cuda:0')
data.h5py: 965 tensor([[963., 963., 963., 964., 965.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([966.], device='cuda:0')
data.h5py: 966 tensor([[963., 963., 964., 965., 966.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([967.], device='cuda:0')
data.h5py: 967 tensor([[963., 964., 965., 966., 967.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([968.], device='cuda:0')
data.h5py: 968 tensor([[964., 965., 966., 967., 968.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([969.], device='cuda:0')
data.h5py: 969 tensor([[965., 966., 967., 968., 969.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([970.], device='cuda:0')
data.h5py: 970 tensor([[966., 967., 968., 969., 970.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([971.], device='cuda:0')
data.h5py: 971 tensor([[967., 968., 969., 970., 971.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([972.], device='cuda:0')
data.h5py: 972 tensor([[968., 969., 970., 971., 972.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([973.], device='cuda:0')
data.h5py: 973 tensor([[969., 970., 971., 972., 973.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([974.], device='cuda:0')
data.h5py: 974 tensor([[970., 971., 972., 973., 974.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([975.], device='cuda:0')
data.h5py: 975 tensor([[971., 972., 973., 974., 975.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([976.], device='cuda:0')
data.h5py: 976 tensor([[972., 973., 974., 975., 976.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([977.], device='cuda:0')
data.h5py: 977 tensor([[973., 974., 975., 976., 977.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([978.], device='cuda:0')
data.h5py: 978 tensor([[974., 975., 976., 977., 978.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([979.], device='cuda:0')
data.h5py: 979 tensor([[975., 976., 977., 978., 979.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([980.], device='cuda:0')
data.h5py: 980 tensor([[980., 980., 980., 980., 980.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([981.], device='cuda:0')
data.h5py: 981 tensor([[980., 980., 980., 980., 981.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([982.], device='cuda:0')
data.h5py: 982 tensor([[980., 980., 980., 981., 982.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([983.], device='cuda:0')
data.h5py: 983 tensor([[980., 980., 981., 982., 983.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([984.], device='cuda:0')
data.h5py: 984 tensor([[980., 981., 982., 983., 984.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([985.], device='cuda:0')
data.h5py: 985 tensor([[981., 982., 983., 984., 985.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([986.], device='cuda:0')
data.h5py: 986 tensor([[982., 983., 984., 985., 986.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([987.], device='cuda:0')
data.h5py: 987 tensor([[983., 984., 985., 986., 987.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([988.], device='cuda:0')
data.h5py: 988 tensor([[984., 985., 986., 987., 988.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([989.], device='cuda:0')
data.h5py: 989 tensor([[985., 986., 987., 988., 989.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([990.], device='cuda:0')
data.h5py: 990 tensor([[986., 987., 988., 989., 990.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([991.], device='cuda:0')
data.h5py: 991 tensor([[987., 988., 989., 990., 991.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([992.], device='cuda:0')
data.h5py: 992 tensor([[988., 989., 990., 991., 992.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([993.], device='cuda:0')
data.h5py: 993 tensor([[989., 990., 991., 992., 993.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([994.], device='cuda:0')
data.h5py: 994 tensor([[990., 991., 992., 993., 994.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([995.], device='cuda:0')
data.h5py: 995 tensor([[991., 992., 993., 994., 995.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([996.], device='cuda:0')
data.h5py: 996 tensor([[992., 993., 994., 995., 996.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([997.], device='cuda:0')
data.h5py: 997 tensor([[993., 994., 995., 996., 997.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([998.], device='cuda:0')
data.h5py: 998 tensor([[994., 995., 996., 997., 998.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([999.], device='cuda:0')
data.h5py: 999 tensor([[995., 996., 997., 998., 999.]], device='cuda:0') torch.Size([1, 5, 10]) tensor([1000.], device='cuda:0')
Last update: March 14, 2021

Comments