Example #1
0
class Precision_16_32Test(unittest.TestCase):
    def setUp(self):
        self.precision_instance = Precision('16.32')

    def test_half_precision_instanciation(self):
        assert (self.precision_instance.compute_precision == tf.float16)
        assert (self.precision_instance.weight_update_precision == tf.float32)

    def test_set_precision(self):
        self.precision_instance.apply()

        input_layer = tf.keras.layers.Input(shape=(None, 1))
        layer = tf.keras.layers.Dense(1)
        assert (layer.compute_dtype == tf.float16)
        output = layer(input_layer)
        assert (output.dtype == tf.float16)

        model = tf.keras.Model(inputs=input_layer, outputs=output)

        with tf.GradientTape() as tape:
            input_data = np.array([[1]])
            output_data = model(input_data)

            grad = tape.gradient(output_data, model.trainable_variables)
            # note gradients dtype are tf.float32
            assert (all([g.dtype == tf.float32 for g in grad]))
        # note that model weights are also tf.float32
        assert (all(
            [var.dtype == tf.float32 for var in model.trainable_variables]))
Example #2
0
class Precision32_32Test(unittest.TestCase):
    def setUp(self):
        self.precision_instance = Precision('32.32')

    def test_full_precision_instantiation(self):
        assert (self.precision_instance.compute_precision == tf.float32)
        assert (self.precision_instance.weight_update_precision == tf.float32)

    def test_set_precision(self):
        self.precision_instance.apply()

        input_layer = tf.keras.layers.Input(shape=(1))
        layer = tf.keras.layers.Dense(1)
        assert (layer.dtype == tf.float32)
        output = layer(input_layer)
        assert (output.dtype == tf.float32)

        model = tf.keras.Model(inputs=input_layer, outputs=output)

        with tf.GradientTape() as tape:
            input_data = np.array([[1]])
            output_data = model(input_data)

            grads = tape.gradient(output_data, model.trainable_variables)
            assert (all([g.dtype == tf.float32 for g in grads]))
Example #3
0
 def test_datenum(self):
     p = Precision()
     d = [i for i in p.dtrange(datetime(2018, 6, 12), datetime(2025, 12, 12), {'days': 1, 'hours':2})]
     x = [p.datenum(i.date()) for i in d]
     self.assertEqual(len(x), 2530, 'Failed datenum!')
     y = [p.datenum(i.year, i.month, i.day) for i in d]
     self.assertEqual(len(x), 2530, 'Failed datenum 2!')
Example #4
0
    def test_unique(self):
        p = Precision()
        l0 = [0, 1, 1, 2, 3, 4, 4, 5, 5, 6, 7, 7, 7]
        self.assertEqual(
            dict({
                0: 4,
                1: 5,
                2: 6,
                3: 7,
                4: 8,
                5: 9,
                6: 10,
                7: 11
            }), p.unique(l0, 4), 'Failed unique 1!')
        self.assertEqual(list([0, 1, 2, 3, 4, 5, 6, 7]), p.unique(l0),
                         'Failed unique 2!')

        x = p.unique(numpy.array([l0]))
        self.assertEqual([0, 1, 2, 3, 4, 5, 6, 7], list(x[0][0].flatten()),
                         'Failed unique 3!')
        self.assertEqual([0, 1, 3, 4, 5, 7, 9, 10], list(x[0][1].flatten()),
                         'Failed unique 4!')
        self.assertEqual([0, 1, 1, 2, 3, 4, 4, 5, 5, 6, 7, 7, 7],
                         list(x[0][2].flatten()), 'Failed unique 5!')
        self.assertEqual([1, 2, 1, 1, 2, 2, 1, 3], list(x[0][3].flatten()),
                         'Failed unique 6!')
Example #5
0
 def test_num2cell(self):
     p = Precision()
     x = numpy.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], numpy.int64)
     z = p.num2cell(x)
     self.assertEqual(3, len(z), 'Failed num2cell!')
     x = numpy.ones((170, 30))
     z = p.num2cell(x)
     self.assertEqual(170, len(z), 'Failed num2cell!')
Example #6
0
 def test_overlap1d(self):
     p = Precision()
     l0 = ['A', 'B', 'A']
     l1 = ['A', 'D', 'A']
     self.assertEqual([[0, ('A', 'A')], [2, ('A', 'A')]],
                      p.overlap1d(l0, l1), 'Failed overlap1d 1!')
     self.assertEqual([[0, 2], [], [0, 2]], list(p.overlap1d(l0, l1, 0)),
                      'Failed overlap1d 2!')
Example #7
0
 def test_zero_or_one(self):
     p = Precision()
     l0 = ['A', 'B', 'A', 'B', 'C']
     self.assertEqual([1, 0, 1, 0, 0], p.zero_or_one(l0, 'A'),
                      'Failed zero or one A!')
     self.assertEqual([0, 1, 0, 1, 0], p.zero_or_one(l0, 'B'),
                      'Failed zero or one B!')
     self.assertEqual([0, 0, 0, 0, 1], p.zero_or_one(l0, 'C'),
                      'Failed zero or one C!')
Example #8
0
 def test_histc(self):
     p = Precision()
     v = numpy.array([[1.5, 2.0, 3], [4, 5.9, 6]], numpy.int64)
     x = p.histc(v, numpy.amax(v) + 1)
     self.assertEqual([1, 1, 1, 0, 1, 1, 1], list(x[0].flatten()),
                      'Failed histc 1!')
     self.assertEqual([
         1.0, 1.7142857142857144, 2.428571428571429, 3.142857142857143,
         3.857142857142857, 4.571428571428571, 5.285714285714286, 6.0
     ], list(x[1].flatten()), 'Failed histc 1!')
Example #9
0
 def test_strcat(self):
     p = Precision()
     df = pandas.DataFrame(data={
         'A': [1, 2],
         'B': [3, 4]
     },
                           dtype=numpy.int8)
     self.assertEqual(list(['1', '2']), p.strcat(df, 'A'),
                      'Failed num2cell A!')
     self.assertEqual(list(['3', '4']), p.strcat(df, 'B'),
                      'Failed num2cell B!')
Example #10
0
    def test_full_precision(self):
        full_precision = Precision('32.32')
        full_precision.apply()

        model = self.get_model()

        computed_value = model(self.input_value).numpy()

        # checking it did NOT underflow
        self.assertAlmostEqual(self.expected_value[0][0],
                               computed_value[0][0],
                               places=10)
Example #11
0
    def test_mixed_precision(self):
        mixed_precision = Precision('16.32')
        mixed_precision.apply()

        model = self.get_model()

        computed_value = model(self.input_value).numpy()

        # checking for underflow
        self.assertNotAlmostEqual(self.expected_value[0][0],
                                  computed_value[0][0],
                                  places=10)
Example #12
0
    def test_half_precision_update(self):
        Precision('16.16').apply()

        weight = self.perform_weight_update()

        # weight didn't change, weight update done in 16 bits
        self.assertEqual(self.weight_initial_value, weight)
Example #13
0
    def test_mixed_precision_update(self):
        Precision('16.32').apply()

        weight = self.perform_weight_update()

        # weight changed, weight update done in 32 bits
        self.assertNotEqual(self.weight_initial_value, weight)
Example #14
0
    def test_prctile(self):
        p = Precision()
        d = [i for i in p.dtrange(datetime(2018, 6, 12), datetime(2059, 12, 12), {'days': 1, 'hours':2})]
        x = [p.datenum(i.date()) for i in d]
        self.assertEqual(len(x), 13992, 'Failed datenum!')

        x1 = p.prctile(x, 5)
        x2 = p.prctile(x, 95)
        r = (x2 - x1)

        self.assertEqual(x1, 737980.1, 'Failed prctile 5 low!')
        self.assertEqual(x2, 751621.9, 'Failed prctile 95 high!')
        self.assertEqual(r, 13641.800000000047, 'Failed prctile delta r!')
Example #15
0
tensorboard = TensorBoard(log_dir=os.path.join("logs", model_name))
history = model.fit(data["X_train"],
                    data["y_train"],
                    batch_size=ObtenerDatos.BATCH_SIZE,
                    epochs=ObtenerDatos.EPOCHS,
                    validation_data=(data["X_test"], data["y_test"]),
                    callbacks=[checkpointer, tensorboard],
                    verbose=1)
model.save(os.path.join("results", model_name) + ".h5")

# evaluate the model
mse, mae = model.evaluate(data["X_test"], data["y_test"], verbose=0)
# calculate the mean absolute error (inverse scaling)
mean_absolute_error = data["column_scaler"]["close"].inverse_transform(
    [[mae]])[0][0]
precision = Precision()
# Predecir
path_model = "results/" + model_name + ".h5"

# predicted_price = predicted_price_open, predicted_price_high, predicted_price_low, predicted_price_close
new_model = keras.models.load_model(path_model)

# priceOpen = predict(new_model, data)[0]
priceHigh = predict(new_model, data)[1]
priceLow = predict(new_model, data)[2]
priceClose = predict(new_model, data)[3]

# Registrar datos del modelo
ReporteTensorflow(
    symbol=ObtenerDatos.ticker_n,
    update_model=f'{ObtenerDatos.from_date} - {ObtenerDatos.to_date}',
Example #16
0
 def test_strcmp(self):
     p = Precision()
     self.assertEqual(True, p.strcmp('A', 'A'), 'Failed strcmp 0!')
     self.assertEqual(False, p.strcmp('B', 'C'), 'Failed strcmp 1!')
Example #17
0
 def test_sprintf(self):
     p = Precision()
     self.assertEqual('50', p.sprintf('%d', 50), 'Failed sprintf %d!')
     self.assertEqual('WORK', p.sprintf('%s', 'WORK'), 'Failed sprintf %s!')
Example #18
0
 def test_num2str(self):
     p = Precision()
     self.assertEqual('5', p.num2str(5), 'Failed str to num!')
     self.assertEqual('5.2', p.num2str(5.2), 'Failed str to float!')
     self.assertEqual('5.459999', p.num2str(5.459999),
                      'Failed str to float!')
Example #19
0
 def test_str2num(self):
     p = Precision()
     self.assertEqual(5, p.str2num('5'), 'Failed int to str!')
     self.assertEqual(5.2, p.str2num('5.2'), 'Failed float to str!')
     self.assertEqual(5.459999, p.str2num('5.459999'),
                      'Failed float to str!')
Example #20
0
 def test_cell2mat(self):
     p = Precision()
     m = [[1, 2], [3, 4]]
     self.assertEqual(len(m), len(p.cell2mat(m)), 'Failed matrix!')
     self.assertEqual(2, len(p.cell2mat('1 2; 3 4')), 'Failed str!')
Example #21
0
 def test_tic_toc(self):
     p = Precision()
     p.tic()
     time.sleep(2)
     p.toc()
Example #22
0
 def test_overlap2d(self):
     p = Precision()
     a, b = p.overlap2d(numpy.array([1, 2, 4, 5]),
                        numpy.array([4, 6, 10, 9, 1]))
     self.assertEqual([0, 2], list(a.flatten()), 'Failed overlap2d 1!')
     self.assertEqual([4, 0], list(b.flatten()), 'Failed overlap2d 2!')
Example #23
0
 def setUp(self):
     self.precision_instance = Precision('16.32')
Example #24
0
    mean_throughput = np.mean(
        [epoch['elements_per_second']
         for epoch in results_dict['epochs']]) * micro_batch_size
    return mean_throughput


if __name__ == '__main__':
    parser = argparse.ArgumentParser(
        description='TF2 classification dataset benchmark')
    parser = add_arguments(parser)
    args = parser.parse_args()

    logging.basicConfig(level=logging.INFO)
    logging.info(f'args = {args}')

    fp_precision = Precision(args.precision)

    eight_bit_transfer = EightBitTransfer(
        compute_precision=fp_precision.compute_precision
    ) if args.eight_bit_transfer else None

    ds, _, ds_size, _ = DatasetFactory.get_dataset(
        dataset_name=args.dataset,
        dataset_path=args.dataset_path,
        split=args.split,
        img_datatype=fp_precision.compute_precision,
        micro_batch_size=args.micro_batch_size,
        eight_bit_transfer=eight_bit_transfer)

    throughput = estimate_ds_throughput(ds, ds_size, args.num_epochs,
                                        args.micro_batch_size)