def test_append(self):
     y_1 = Labels(labels=mock_labels[:50], index=mock_index[:50])
     y_2 = Labels(labels=mock_labels[50:], index=mock_index[50:])
     y_1.append(y_2)
     for i in range(len(self.labels)):
         assert np.array_equal(y_1[i], self.labels[i])
     assert len(y_1) == len(self.labels)
     assert y_1.shape == self.labels.shape
     assert np.array_equal(y_1.index, self.labels.index)
 def setUp(self) -> None:
     self.x_generator = XGenerator(raw_index=mock_index + len_mock,
                                   raw_sequence=mock_prices,
                                   x_window=x_window,
                                   x_exist=x_exist)
     self.labels = Labels(labels=mock_labels,
                          index=mock_index,
                          with_index=False)
     self.dataset = Dataset(x=self.x_generator, y=self.labels, name="test")
 def setUp(self) -> None:
     self.plus_index = 0
     x_exist_new = np.ones(len_mock, np.bool)
     x_window = 1
     self.x_generator = XGenerator(raw_index=mock_index + self.plus_index,
                                   raw_sequence=mock_prices,
                                   x_window=x_window,
                                   x_exist=x_exist_new)
     self.labels = Labels(labels=mock_labels,
                          index=mock_index,
                          with_index=False)
     self.dataset = Dataset(x=self.x_generator, y=self.labels, name="test")
 def setUp(self) -> None:
     self.class_high = [0, 0]
     self.class_low = [1, 1]
     mock_labels_2 = np.asarray([self.class_high for _ in range(len_mock)])
     mock_labels_2[50] = self.class_low
     self.x_generator = XGenerator(raw_index=mock_index,
                                   raw_sequence=mock_prices,
                                   x_window=x_window,
                                   x_exist=x_exist)
     self.labels = Labels(labels=mock_labels_2,
                          index=mock_index,
                          with_index=False)
     self.dataset = Dataset(x=self.x_generator, y=self.labels, name="test")
    def setUp(self) -> None:
        len_mock = 1000
        x_window = 10

        self.mock_prices = np.arange(len_mock, dtype=np.int)

        start_index = np.datetime64(0, "ns")
        mock_index = []
        mock_index.append(start_index)
        for i in range(1, len_mock):
            mock_index.append(mock_index[-1] + 1)
        self.mock_index = np.asarray(mock_index)

        x_exist = np.ones(self.mock_index.shape, dtype=np.bool)
        self.x_non_exist = 30
        x_exist[:x_non_exist] = False
        self.batch_size = 2
        multi_class_n = 2
        self.mock_labels = np.repeat(np.arange(len_mock, dtype=np.int),
                                     multi_class_n).reshape(
                                         (len_mock, multi_class_n))

        self.x_generator = XGenerator(raw_index=self.mock_index,
                                      raw_sequence=self.mock_prices,
                                      x_window=x_window,
                                      x_exist=x_exist)
        self.labels = Labels(labels=self.mock_labels,
                             index=self.mock_index,
                             with_index=False)
        self.dataset = Dataset(x=self.x_generator, y=self.labels, name="test")
        self.batch_generator = BatchGenerator(dataset=self.dataset,
                                              batch_size=self.batch_size,
                                              shuffle=False,
                                              oversampling=False,
                                              iterations=None,
                                              stride=None,
                                              x_only=False)
x_window = 10

start_index = np.datetime64(0, "ns")
mock_index = []
mock_index.append(start_index)
for i in range(1, len_mock):
    mock_index.append(mock_index[-1] + 1)
mock_index = np.asarray(mock_index)

multi_class_n = 2
mock_labels = np.repeat(np.arange(len_mock, dtype=np.int),
                        multi_class_n).reshape((len_mock, multi_class_n))

if __name__ == "__main__":

    labels = Labels(labels=mock_labels, index=mock_index, with_index=False)

    samples = len(labels)
    start = time.clock()
    for i in range(samples):
        test_sample = labels[i]
    duration = time.clock() - start
    print(f"Samples per second:{samples / duration}")
    # in run mode ~ 500k - 1000k /s

    labels = Labels(labels=mock_labels, index=mock_index, with_index=True)

    samples = len(labels)
    start = time.clock()
    for i in range(samples):
        test_sample = labels[i]
start_index = np.datetime64(0, "ns")
mock_index = []
mock_index.append(start_index)
for i in range(1, len_mock):
    mock_index.append(mock_index[-1] + 1)
mock_index = np.asarray(mock_index)

mock_labels = np.repeat(np.arange(len_mock, dtype=np.int), 2).reshape(
    (len_mock, 2))

x_exist = np.ones(mock_index.shape, dtype=np.bool)
x_non_exist = 30
x_exist[:x_non_exist] = False

if __name__ == "__main__":
    labels = Labels(labels=mock_labels, index=mock_index, with_index=False)
    x_generator = XGenerator(raw_sequence=mock_sequence,
                             raw_index=mock_index,
                             x_window=x_window,
                             x_exist=x_exist,
                             with_index=False)
    dataset = Dataset(x=x_generator, y=labels, name="tutorial")

    batch_size = 10
    batch_generator = BatchGenerator(dataset=dataset,
                                     batch_size=batch_size,
                                     shuffle=True,
                                     stride=None)

    samples = len(batch_generator)
    start = time.clock()
 def setUp(self) -> None:
     self.labels = Labels(labels=mock_labels,
                          index=mock_index,
                          with_index=False)