def test_3_tensorflow_classifier(self):
        """
        First test with the TensorFlowClassifier.
        :return:
        """
        # Build TensorFlowClassifier
        victim_tfc, sess = get_image_classifier_tf()

        # Create the thieved classifier
        thieved_tfc, _ = get_image_classifier_tf(load_init=False, sess=sess)

        # Create random attack
        attack = KnockoffNets(
            classifier=victim_tfc,
            batch_size_fit=BATCH_SIZE,
            batch_size_query=BATCH_SIZE,
            nb_epochs=NB_EPOCHS,
            nb_stolen=NB_STOLEN,
            sampling_strategy="random",
            verbose=False,
        )
        thieved_tfc = attack.extract(x=self.x_train_mnist, thieved_classifier=thieved_tfc)

        victim_preds = np.argmax(victim_tfc.predict(x=self.x_train_mnist), axis=1)
        thieved_preds = np.argmax(thieved_tfc.predict(x=self.x_train_mnist), axis=1)
        acc = np.sum(victim_preds == thieved_preds) / len(victim_preds)

        self.assertGreater(acc, 0.3)

        # Create adaptive attack
        attack = KnockoffNets(
            classifier=victim_tfc,
            batch_size_fit=BATCH_SIZE,
            batch_size_query=BATCH_SIZE,
            nb_epochs=NB_EPOCHS,
            nb_stolen=NB_STOLEN,
            sampling_strategy="adaptive",
            reward="all",
            verbose=False,
        )
        thieved_tfc = attack.extract(x=self.x_train_mnist, y=self.y_train_mnist, thieved_classifier=thieved_tfc)

        victim_preds = np.argmax(victim_tfc.predict(x=self.x_train_mnist), axis=1)
        thieved_preds = np.argmax(thieved_tfc.predict(x=self.x_train_mnist), axis=1)
        acc = np.sum(victim_preds == thieved_preds) / len(victim_preds)

        self.assertGreater(acc, 0.4)

        with self.assertRaises(ValueError):
            _ = KnockoffNets(
                classifier=victim_tfc,
                batch_size_fit=-1,
                batch_size_query=BATCH_SIZE,
                nb_epochs=NB_EPOCHS,
                nb_stolen=NB_STOLEN,
                sampling_strategy="adaptive",
                reward="all",
                verbose=False,
            )

        with self.assertRaises(ValueError):
            _ = KnockoffNets(
                classifier=victim_tfc,
                batch_size_fit=BATCH_SIZE,
                batch_size_query=-1,
                nb_epochs=NB_EPOCHS,
                nb_stolen=NB_STOLEN,
                sampling_strategy="adaptive",
                reward="all",
                verbose=False,
            )

        with self.assertRaises(ValueError):
            _ = KnockoffNets(
                classifier=victim_tfc,
                batch_size_fit=BATCH_SIZE,
                batch_size_query=BATCH_SIZE,
                nb_epochs=-1,
                nb_stolen=NB_STOLEN,
                sampling_strategy="adaptive",
                reward="all",
                verbose=False,
            )

        with self.assertRaises(ValueError):
            _ = KnockoffNets(
                classifier=victim_tfc,
                batch_size_fit=BATCH_SIZE,
                batch_size_query=BATCH_SIZE,
                nb_epochs=NB_EPOCHS,
                nb_stolen=-1,
                sampling_strategy="adaptive",
                reward="all",
                verbose=False,
            )

        with self.assertRaises(ValueError):
            _ = KnockoffNets(
                classifier=victim_tfc,
                batch_size_fit=BATCH_SIZE,
                batch_size_query=BATCH_SIZE,
                nb_epochs=NB_EPOCHS,
                nb_stolen=NB_STOLEN,
                sampling_strategy="test",
                reward="all",
                verbose=False,
            )

        with self.assertRaises(ValueError):
            _ = KnockoffNets(
                classifier=victim_tfc,
                batch_size_fit=BATCH_SIZE,
                batch_size_query=BATCH_SIZE,
                nb_epochs=NB_EPOCHS,
                nb_stolen=NB_STOLEN,
                sampling_strategy="adaptive",
                reward="test",
                verbose=False,
            )

        with self.assertRaises(ValueError):
            _ = KnockoffNets(
                classifier=victim_tfc,
                batch_size_fit=BATCH_SIZE,
                batch_size_query=BATCH_SIZE,
                nb_epochs=NB_EPOCHS,
                nb_stolen=NB_STOLEN,
                sampling_strategy="adaptive",
                reward="all",
                verbose="False",
            )

        with self.assertRaises(ValueError):
            _ = KnockoffNets(
                classifier=victim_tfc,
                batch_size_fit=BATCH_SIZE,
                batch_size_query=BATCH_SIZE,
                nb_epochs=NB_EPOCHS,
                nb_stolen=NB_STOLEN,
                sampling_strategy="adaptive",
                reward="all",
                verbose=False,
                use_probability="True",
            )

        # Clean-up session
        if sess is not None:
            sess.close()

        First test with the TensorFlowClassifier.
        :return:
        
tests/attacks/test_knockoff_nets.py