def test_apogee_cnn(self): # Apogee_CNN print("======Apogee_CNN======") neuralnet = ApogeeCNN() neuralnet.max_epochs = 1 neuralnet.callbacks = ErrorOnNaN() neuralnet.train(random_xdata, random_ydata) prediction = neuralnet.test(random_xdata) jacobian = neuralnet.jacobian(random_xdata[:10]) np.testing.assert_array_equal(prediction.shape, random_ydata.shape) np.testing.assert_array_equal(jacobian.shape, [random_xdata[:10].shape[0], random_ydata.shape[1], random_xdata.shape[1]]) neuralnet.save(name='apogee_cnn') neuralnet_loaded = load_folder("apogee_cnn") neuralnet_loaded.max_epochs = 1 neuralnet_loaded.callbacks = ErrorOnNaN() prediction_loaded = neuralnet_loaded.test(random_xdata) # Apogee_CNN is deterministic np.testing.assert_array_equal(prediction, prediction_loaded) # Fine tuning test neuralnet_loaded.train(random_xdata, random_ydata) prediction_loaded = neuralnet_loaded.test(random_xdata) # prediction should not be equal after fine-tuning self.assertRaises(AssertionError, np.testing.assert_array_equal, prediction, prediction_loaded)
def test_apogeedr14_gaiadr2(self): """ Test ApogeeDR14GaiaDR2BCNN models - training, testing, evaluation """ # Data preparation random_xdata_error1 = np.random.normal(0, 1, (200, 7514)) random_xdata_error2 = np.random.normal(0, 1, (200, 7515)) random_xdata = np.random.normal(0, 1, (200, 7516)) # ApogeeBCNNCensored print("======ApogeeDR14GaiaDR2BCNN======") random_ydata = np.random.normal(0, 1, (200, 1)) apogeedr14gaiadr2bcnn = ApogeeDR14GaiaDR2BCNN() apogeedr14gaiadr2bcnn.max_epochs = 1 apogeedr14gaiadr2bcnn.callbacks = ErrorOnNaN() self.assertRaises(IndexError, apogeedr14gaiadr2bcnn.train, random_xdata_error1, random_ydata) apogeedr14gaiadr2bcnn = ApogeeDR14GaiaDR2BCNN() apogeedr14gaiadr2bcnn.max_epochs = 1 apogeedr14gaiadr2bcnn.callbacks = ErrorOnNaN() self.assertRaises(ValueError, apogeedr14gaiadr2bcnn.train, random_xdata_error2, random_ydata) apogeedr14gaiadr2bcnn = ApogeeDR14GaiaDR2BCNN() apogeedr14gaiadr2bcnn.max_epochs = 1 apogeedr14gaiadr2bcnn.callbacks = ErrorOnNaN() apogeedr14gaiadr2bcnn.train(random_xdata, random_ydata) # prevent memory issue on Tavis CI apogeedr14gaiadr2bcnn.mc_num = 2 prediction, prediction_err = apogeedr14gaiadr2bcnn.test(random_xdata) np.testing.assert_array_equal(prediction.shape, random_ydata.shape) apogeedr14gaiadr2bcnn.save(name='apogeedr14_gaiadr2') bneuralnetcensored_loaded = load_folder("apogeedr14_gaiadr2")
def test_apogee_cvae(self): # Data preparation random_xdata = np.random.normal(0, 1, (200, 7514)) # ApogeeCVAE print("======ApogeeCVAE======") cvae_net = ApogeeCVAE() cvae_net.max_epochs = 1 cvae_net.latent_dim = 2 cvae_net.callbacks = ErrorOnNaN() cvae_net.train(random_xdata, random_xdata) prediction = cvae_net.test(random_xdata) encoding = cvae_net.test_encoder(random_xdata) print(cvae_net.evaluate(random_xdata, random_xdata)) np.testing.assert_array_equal(prediction.shape, np.expand_dims(random_xdata, axis=-1).shape) np.testing.assert_array_equal(encoding.shape, [random_xdata.shape[0], cvae_net.latent_dim]) cvae_net.save(name='apogee_cvae') # just to make sure it can load it back without error cvae_net_loaded = load_folder("apogee_cvae") encoding = cvae_net_loaded.test_encoder(random_xdata) np.testing.assert_array_equal(encoding.shape, [random_xdata.shape[0], cvae_net.latent_dim]) # Fine-tuning test cvae_net_loaded.max_epochs = 1 cvae_net.callbacks = ErrorOnNaN() cvae_net_loaded.train(random_xdata, random_xdata)
def test_apogee_bcnn(self): """ Test ApogeeBCNN models - training, testing, evaluation - Apogee plotting functions """ # ApogeeBCNN print("======ApogeeBCNN======") bneuralnet = ApogeeBCNN() # deliberately chosen targetname to test targetname conversion too bneuralnet.targetname = ['logg', 'feh'] bneuralnet.max_epochs = 5 # for quick result bneuralnet.callbacks = ErrorOnNaN( ) # Raise error and fail the test if Nan bneuralnet.train(xdata, ydata) output_shape = bneuralnet.output_shape input_shape = bneuralnet.input_shape bneuralnet.mc_num = 2 prediction, prediction_err = bneuralnet.test(xdata) mape = np.median( np.abs(prediction[bneuralnet.val_idx] - ydata[bneuralnet.val_idx]) / ydata[bneuralnet.val_idx], axis=0) self.assertEqual(np.all(0.15 > mape), True) # assert less than 15% error self.assertEqual( np.all(0.25 > np.median(prediction_err['total'], axis=0)), True) # assert entropy # assert all of them not equal becaues of MC Dropout self.assertEqual( np.all( bneuralnet.evaluate(xdata, ydata) != bneuralnet.evaluate( xdata, ydata)), True) jacobian = bneuralnet.jacobian(xdata[:2], mean_output=True) np.testing.assert_array_equal(prediction.shape, ydata.shape) bneuralnet.save(name='apogee_bcnn') bneuralnet.train_on_batch(xdata[:64], ydata[:64]) # single batch fine-tuning test # just to make sure it can load it back without error bneuralnet_loaded = load_folder("apogee_bcnn") # prevent memory issue on Tavis CI bneuralnet_loaded.mc_num = 2 pred, pred_err = bneuralnet_loaded.test(xdata) bneuralnet_loaded.save() # Fine-tuning test bneuralnet_loaded.max_epochs = 5 bneuralnet_loaded.callbacks = ErrorOnNaN() bneuralnet_loaded.train(xdata, ydata)
def test_apogee_bcnn(self): """ Test ApogeeBCNN models - training, testing, evaluation - Apogee plotting functions """ # Data preparation random_xdata = np.random.normal(0, 1, (200, 7514)) random_ydata = np.random.normal(0, 1, (200, 7)) # ApogeeBCNN print("======ApogeeBCNN======") bneuralnet = ApogeeBCNN() # deliberately chosen targetname to test targetname conversion too bneuralnet.targetname = [ 'teff', 'logg', 'M', 'alpha', 'C1', 'Ti', 'Ti2' ] bneuralnet.max_epochs = 1 # for quick result bneuralnet.callbacks = ErrorOnNaN( ) # Raise error and fail the test if Nan bneuralnet.train(random_xdata, random_ydata) output_shape = bneuralnet.output_shape input_shape = bneuralnet.input_shape # prevent memory issue on Tavis CI so set mc_num=2 bneuralnet.mc_num = 2 prediction, prediction_err = bneuralnet.test(random_xdata) # assert all of them not equal becaues of MC Dropout self.assertEqual( np.all( bneuralnet.evaluate(random_xdata, random_ydata) != bneuralnet.evaluate(random_xdata, random_ydata)), True) jacobian = bneuralnet.jacobian(random_xdata[:2], mean_output=True) np.testing.assert_array_equal(prediction.shape, random_ydata.shape) bneuralnet.save(name='apogee_bcnn') bneuralnet.train_on_batch( random_xdata, random_ydata) # single batch fine-tuning test # just to make sure it can load it back without error bneuralnet_loaded = load_folder("apogee_bcnn") # prevent memory issue on Tavis CI bneuralnet_loaded.mc_num = 2 pred, pred_err = bneuralnet_loaded.test(random_xdata) bneuralnet_loaded.aspcap_residue_plot(pred, pred, pred_err['total']) bneuralnet_loaded.jacobian_aspcap(jacobian) bneuralnet_loaded.save() # Fine-tuning test bneuralnet_loaded.max_epochs = 1 bneuralnet_loaded.callbacks = ErrorOnNaN() bneuralnet_loaded.train(random_xdata, random_ydata) pred, pred_err = bneuralnet_loaded.test_old(random_xdata)
def test_bayesian_mnist(self): import pylab as plt # Create a astroNN neural network instance and set the basic parameter net = MNIST_BCNN() net.task = 'classification' net.callbacks = ErrorOnNaN() net.max_epochs = 1 # Train the neural network net.train(x_train, y_train) net.save('mnist_bcnn_test') net.plot_dense_stats() plt.close() # Travis-CI memory error?? net.evaluate(x_test, utils.to_categorical(y_test, 10)) pred, pred_err = net.test(x_test) test_num = y_test.shape[0] assert (np.sum(pred == y_test)) / test_num > 0.9 # assert accuracy net_reloaded = load_folder("mnist_bcnn_test") net_reloaded.mc_num = 3 # prevent memory issue on Tavis CI prediction_loaded = net_reloaded.test(x_test[:200]) net_reloaded.folder_name = None # set to None so it can be saved net_reloaded.save() load_folder(net_reloaded.folder_name) # ignore pycharm warning, its not None
def test_color_images(self): # test colored 8bit images (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train = np.random.randint(0, 255, size=(1000, 28, 28, 3)) x_test = np.random.randint(0, 255, size=(100, 28, 28, 3)) y_train = y_train[:1000] y_train = np_utils.to_categorical(y_train, 10) # To convert to desirable type x_train = x_train.astype(np.float32) x_test = x_test.astype(np.float32) y_train = y_train.astype(np.float32) # create model instance mnist_test = Cifar10CNN() mnist_test.max_epochs = 1 mnist_test.callbacks = ErrorOnNaN() mnist_test.train(x_train, y_train[:1000]) mnist_test.test(x_test[:1000]) # create model instance for binary classification mnist_test = Galaxy10CNN() mnist_test.max_epochs = 1 mnist_test.train(x_train[:1000], y_train[:1000]) prediction = mnist_test.test(x_test[:1000]) mnist_test.save('cifar10_test') mnist_reloaded = load_folder("cifar10_test") prediction_loaded = mnist_reloaded.test(x_test[:1000]) mnist_reloaded.jacobian(x_test[:10], mean_output=True, mc_num=2) # Cifar10_CNN is deterministic np.testing.assert_array_equal(prediction, prediction_loaded)
def test_mnist(self): (x_train, y_train), (x_test, y_test) = mnist.load_data() y_train = utils.to_categorical(y_train, 10) # To convert to desirable type x_train = x_train.astype(np.float32) x_test = x_test.astype(np.float32) y_train = y_train.astype(np.float32) # create model instance mnist_test = Cifar10CNN() mnist_test.max_epochs = 1 mnist_test.callbacks = ErrorOnNaN() mnist_test.train(x_train[:200], y_train[:200]) output_shape = mnist_test.output_shape mnist_test.test(x_test[:200]) mnist_test.evaluate(x_train[:100], y_train[:100]) # create model instance for binary classification mnist_test = Cifar10CNN() mnist_test.max_epochs = 1 mnist_test.task = 'binary_classification' mnist_test.train(x_train[:200], y_train[:200]) prediction = mnist_test.test(x_test[:200]) mnist_test.save('mnist_test') mnist_reloaded = load_folder("mnist_test") prediction_loaded = mnist_reloaded.test(x_test[:200]) mnist_reloaded.jacobian_old(x_test[:2]) # Cifar10_CNN is deterministic np.testing.assert_array_equal(prediction, prediction_loaded)
def test_bayesian_mnist(self): from astroNN.models import MNIST_BCNN import pylab as plt (x_train, y_train), (x_test, y_test) = mnist.load_data() y_train = utils.to_categorical(y_train, 10) # To convert to desirable type y_train = y_train.astype(np.float32) x_train = x_train.astype(np.float32) x_test = x_test.astype(np.float32) # Create a astroNN neural network instance and set the basic parameter net = MNIST_BCNN() net.task = 'classification' net.callbacks = ErrorOnNaN() net.max_epochs = 1 # Just use 5 epochs for quick result # Trian the nerual network net.train(x_train[:200], y_train[:200]) plt.close() # Travis-CI memory error?? # net.plot_model() # disable due to memory issue on Travis CI net.save('mnist_bcnn_test') net.plot_dense_stats() net.evaluate(x_train[:10], y_train[:10]) net_reloaded = load_folder("mnist_bcnn_test") net_reloaded.mc_num = 3 # prevent memory issue on Tavis CI prediction_loaded = net_reloaded.test(x_test[:200]) net_reloaded.folder_name = None # set to None so it can be saved net_reloaded.save() load_folder( net_reloaded.folder_name) # ignore pycharm warning, its not None
def test_color_images(self): # create model instance mnist_test = Cifar10CNN() mnist_test.max_epochs = 1 mnist_test.callbacks = ErrorOnNaN() mnist_test.train(x_train_color, y_train) pred = mnist_test.test(x_test_color) test_num = y_test.shape[0] assert (np.sum(np.argmax(pred, axis=1) == y_test)) / test_num > 0.9 # assert accuracy # create model instance for binary classification mnist_test = Galaxy10CNN() mnist_test.max_epochs = 1 mnist_test.mc_num = 3 mnist_test.train(x_train[:200], y_train[:200]) prediction = mnist_test.test(x_test[:200]) mnist_test.save('cifar10_test') mnist_reloaded = load_folder("cifar10_test") prediction_loaded = mnist_reloaded.test(x_test[:200]) mnist_reloaded.jacobian(x_test[:2], mean_output=True, mc_num=2) # mnist_reloaded.hessian_diag(x_test[:10], mean_output=True, mc_num=2) # Cifar10_CNN is deterministic np.testing.assert_array_equal(prediction, prediction_loaded)
def test_apogee_bcnn(self): random_xdata = np.random.normal(0, 1, (200, 7514)) random_ydata = np.random.normal(0, 1, (200, 7)) # ApogeeBCNN print("======ApogeeBCNN======") bneuralnet = ApogeeBCNN() bneuralnet.targetname = [ 'teff', 'logg', 'M', 'alpha', 'C1', 'Ti', 'Ti2' ] bneuralnet.max_epochs = 1 bneuralnet.callbacks = ErrorOnNaN() bneuralnet.train(random_xdata, random_ydata) output_shape = bneuralnet.output_shape input_shape = bneuralnet.input_shape # prevent memory issue on Tavis CI bneuralnet.mc_num = 3 prediction, prediction_err = bneuralnet.test(random_xdata) print(bneuralnet.evaluate(random_xdata, random_ydata)) bneuralnet.plot_dense_stats() bneuralnet.plot_model() jacobian = bneuralnet.jacobian(random_xdata[:3], mean_output=True) np.testing.assert_array_equal(prediction.shape, random_ydata.shape) bneuralnet.save(name='apogee_bcnn') # just to make sure it can load it back without error bneuralnet_loaded = load_folder("apogee_bcnn") bneuralnet_loaded.plot_dense_stats() bneuralnet_loaded.callbacks = ErrorOnNaN() # prevent memory issue on Tavis CI bneuralnet_loaded.mc_num = 2 pred, pred_err = bneuralnet_loaded.test(random_xdata) bneuralnet_loaded.aspcap_residue_plot(pred, pred, pred_err['total']) bneuralnet_loaded.jacobian_aspcap(jacobian) bneuralnet_loaded.save() # Fine-tuning test bneuralnet_loaded.max_epochs = 1 bneuralnet_loaded.train(random_xdata, random_ydata) pred, pred_err = bneuralnet_loaded.test_old(random_xdata)
def test_bayesian_binary_mnist(self): # Create a astroNN neural network instance and set the basic parameter net = MNIST_BCNN() net.task = 'binary_classification' net.callbacks = ErrorOnNaN() net.max_epochs = 1 net.train(x_train, y_train) pred, pred_err = net.test(x_test) test_num = y_test.shape[0] net.save('mnist_binary_bcnn_test') net_reloaded = load_folder("mnist_binary_bcnn_test") net_reloaded.mc_num = 3 prediction_loaded, prediction_loaded_err = net_reloaded.test(x_test)
def test_bayesian_binary_mnist(self): # Create a astroNN neural network instance and set the basic parameter net = MNIST_BCNN() net.task = 'binary_classification' net.callbacks = ErrorOnNaN() net.max_epochs = 1 # Just use 1 epochs for quick result # Train the neural network net.train(self.x_train[:200], self.y_train[:200]) net.save('mnist_binary_bcnn_test') net_reloaded = load_folder("mnist_binary_bcnn_test") net_reloaded.mc_num = 3 # prevent memory issue on Tavis CI prediction_loaded = net_reloaded.test(self.x_test[:200])
def test_starnet2017(self): # Data preparation, keep the data size large (>800 data points to prevent issues) random_xdata = np.random.normal(0, 1, (200, 7514)) random_ydata = np.random.normal(0, 1, (200, 25)) # StarNet2017 print("======StarNet2017======") starnet2017 = StarNet2017() starnet2017.max_epochs = 1 starnet2017.callbacks = ErrorOnNaN() starnet2017.train(random_xdata, random_ydata) prediction = starnet2017.test(random_xdata) np.testing.assert_array_equal(prediction.shape, random_ydata.shape) starnet2017.save(name='starnet2017')
def test_mnist(self): (x_train, y_train), (x_test, y_test) = mnist.load_data() y_train = utils.to_categorical(y_train, 10) # To convert to desirable type x_train = x_train.astype(np.float32) x_test = x_test.astype(np.float32) y_train = y_train.astype(np.float32) # create model instance mnist_test = Cifar10CNN() mnist_test.max_epochs = 1 mnist_test.callbacks = ErrorOnNaN() mnist_test.train(x_train[:200], y_train[:200]) output_shape = mnist_test.output_shape mnist_test.test(x_test[:200]) mnist_test.evaluate(x_train[:100], y_train[:100]) # create model instance for binary classification mnist_test = Cifar10CNN() mnist_test.max_epochs = 1 mnist_test.task = 'binary_classification' mnist_test.train(x_train[200:400], y_train[200:400].astype(bool)) prediction = mnist_test.test(x_test[200:400]) print("12345: ", mnist_test.input_std) mnist_test.save('mnist_test') print("12345: ", mnist_test.input_std) mnist_reloaded = load_folder("mnist_test") prediction_loaded = mnist_reloaded.test(x_test[200:400]) mnist_reloaded.jacobian_old(x_test[:2]) eval_result = mnist_reloaded.evaluate(x_test[200:400], y_train[200:400].astype(bool)) # Cifar10_CNN without dropout is deterministic np.testing.assert_array_equal(prediction, prediction_loaded) # test verbose metrics mnist_reloaded.metrics = ['accuracy'] mnist_reloaded.compile() print("12345: ", mnist_test.input_std) mnist_test.save('mnist_test_accuracy') mnist_reloaded_again = load_folder("mnist_test_accuracy") eval_result_again = mnist_reloaded_again.evaluate( x_test[200:400], y_train[200:400]) # assert saving again wont affect the model self.assertAlmostEqual(eval_result_again['loss'], eval_result['loss'], places=3)
def test_starnet2017(self): # StarNet2017 print("======StarNet2017======") starnet2017 = StarNet2017() starnet2017.max_epochs = 1 starnet2017.callbacks = ErrorOnNaN() starnet2017.train(random_xdata, random_ydata) prediction = starnet2017.test(random_xdata) jacobian = starnet2017.jacobian(random_xdata[:10]) np.testing.assert_array_equal(prediction.shape, random_ydata.shape) np.testing.assert_array_equal(jacobian.shape, [random_xdata[:10].shape[0], random_ydata.shape[1], random_xdata.shape[1]]) starnet2017.save(name='starnet2017') starnet2017_loaded = load_folder("starnet2017") prediction_loaded = starnet2017_loaded.test(random_xdata) # StarNet2017 is deterministic np.testing.assert_array_equal(prediction, prediction_loaded) # Fine-tuning test starnet2017_loaded.max_epochs = 1 starnet2017.callbacks = ErrorOnNaN() starnet2017_loaded.train(random_xdata, random_ydata)
def test_mnist(self): # create model instance mnist_test = Cifar10CNN() mnist_test.max_epochs = 1 mnist_test.callbacks = ErrorOnNaN() mnist_test.train(x_train, y_train) output_shape = mnist_test.output_shape pred = mnist_test.test(x_test) test_num = y_test.shape[0] assert (np.sum(np.argmax(pred, axis=1) == y_test) ) / test_num > 0.9 # assert accurancy mnist_test.evaluate(x_test, utils.to_categorical(y_test, 10)) # create model instance for binary classification mnist_test = Cifar10CNN() mnist_test.max_epochs = 2 mnist_test.task = 'binary_classification' mnist_test.train(x_train, y_train.astype(bool)) prediction = mnist_test.test(x_test) assert (np.sum(np.argmax(prediction, axis=1) == y_test) ) / test_num > 0.9 # assert accuracy mnist_test.save('mnist_test') mnist_reloaded = load_folder("mnist_test") prediction_loaded = mnist_reloaded.test(x_test) eval_result = mnist_reloaded.evaluate(x_test, utils.to_categorical(y_test, 10)) # Cifar10_CNN without dropout is deterministic np.testing.assert_array_equal(prediction, prediction_loaded) # test verbose metrics mnist_reloaded.metrics = ['accuracy'] mnist_reloaded.compile() mnist_test.save('mnist_test_accuracy') mnist_reloaded_again = load_folder("mnist_test_accuracy") # test with astype boolean deliberately eval_result_again = mnist_reloaded_again.evaluate( x_test, utils.to_categorical(y_test, 10).astype(bool)) # assert saving again wont affect the model self.assertAlmostEqual(eval_result_again['loss'], eval_result['loss'], places=3)
def test_apogee_bcnnconsered(self): random_xdata = np.random.normal(0, 1, (200, 7514)) # ApogeeBCNNCensored print("======ApogeeBCNNCensored======") bneuralnetcensored = ApogeeBCNNCensored() datalen = len(bneuralnetcensored.targetname) random_ydata = np.random.normal(0, 1, (200, datalen)) bneuralnetcensored.max_epochs = 1 bneuralnetcensored.callbacks = ErrorOnNaN() bneuralnetcensored.train(random_xdata, random_ydata) output_shape = bneuralnetcensored.output_shape input_shape = bneuralnetcensored.input_shape # prevent memory issue on Tavis CI bneuralnetcensored.mc_num = 3 prediction, prediction_err = bneuralnetcensored.test(random_xdata) np.testing.assert_array_equal(prediction.shape, random_ydata.shape) bneuralnetcensored.save(name='apogee_bcnncensored') bneuralnetcensored_loaded = load_folder("apogee_bcnncensored")
def test_bayesian_binary_mnist(self): (x_train, y_train), (x_test, y_test) = mnist.load_data() y_train = utils.to_categorical(y_train, 10) y_train = y_train.astype(np.float32) x_train = x_train.astype(np.float32) x_test = x_test.astype(np.float32) # Create a astroNN neural network instance and set the basic parameter net = MNIST_BCNN() net.task = 'binary_classification' net.callbacks = ErrorOnNaN() net.max_epochs = 1 # Just use 5 epochs for quick result # Trian the nerual network net.train(x_train[:200], y_train[:200]) net.save('mnist_binary_bcnn_test') net_reloaded = load_folder("mnist_binary_bcnn_test") net_reloaded.mc_num = 3 # prevent memory issue on Tavis CI prediction_loaded = net_reloaded.test(x_test[:200])
def test_ApogeeKplerEchelle(self): """ Test ApogeeKplerEchelle models - training, testing """ # Data preparation, keep the data size large (>800 data points to prevent issues) (x_train, y_train), (x_test, y_test) = mnist.load_data() y_train = utils.to_categorical(y_train, 10) y_test = utils.to_categorical(y_test, 10) # To convert to desirable type y_train = y_train.astype(np.float32) y_test = y_test.astype(np.float32) x_train = x_train.astype(np.float32) x_test = x_test.astype(np.float32) print("======ApogeeKplerEchelle======") apokasc_nn = ApogeeKplerEchelle() apokasc_nn.max_epochs = 2 apokasc_nn.dropout_rate = 0. apokasc_nn.input_norm_mode = {'input': 255, 'aux': 0} apokasc_nn.labels_norm_mode = 0 apokasc_nn.task = 'classification' apokasc_nn.callbacks = ErrorOnNaN() apokasc_nn.train({ 'input': x_train, 'aux': y_train }, {'output': y_train}) prediction = apokasc_nn.test({'input': x_train, 'aux': y_train}) # we ave the answer as aux input so the prediction should be near perfect total_num = y_train.shape[0] assert np.sum((prediction > 0.5) == (y_train > 0.5)) > total_num * 0.99 apokasc_nn.save(name='apokasc_nn') apokasc_nn_reloaded = load_folder('apokasc_nn') prediction_reloaded = apokasc_nn_reloaded.test({ 'input': x_train, 'aux': y_train }) np.testing.assert_array_equal(prediction, prediction_reloaded)
def test_apogee_cnn(self): """ Test ApogeeCNN models - training, testing, evaluation - basic astroNN model method """ print("======ApogeeCNN======") # Data preparation random_xdata = np.random.normal(0, 1, (200, 1024)) random_ydata = np.random.normal(0, 1, (200, 2)) # setup model instance neuralnet = ApogeeCNN() print(neuralnet) # assert no model before training self.assertEqual(neuralnet.has_model, False) neuralnet.max_epochs = 1 # for quick result neuralnet.callbacks = ErrorOnNaN() # Raise error and fail the test if Nan neuralnet.train(random_xdata, random_ydata) # training self.assertEqual(neuralnet.uses_learning_phase, True) # Assert ApogeeCNN uses learning phase (bc of Dropout) # test basic astroNN model method neuralnet.get_weights() neuralnet.summary() output_shape = neuralnet.output_shape input_shape = neuralnet.input_shape neuralnet.get_config() neuralnet.save_weights('save_weights_test.h5') # save astroNN weight only neuralnet.plot_dense_stats() neuralnet.plot_model() prediction = neuralnet.test(random_xdata) jacobian = neuralnet.jacobian(random_xdata[:2]) hessian = neuralnet.hessian_diag(random_xdata[:2]) hessian_full_approx = neuralnet.hessian(random_xdata[:2], method='approx') hessian_full_exact = neuralnet.hessian(random_xdata[:2], method='exact') # make sure raised if data dimension not as expected self.assertRaises(ValueError, neuralnet.jacobian, np.atleast_3d(random_xdata[:3])) # make sure evaluate run in testing phase instead of learning phase # ie no Dropout which makes model deterministic self.assertEqual( np.all(neuralnet.evaluate(random_xdata, random_ydata) == neuralnet.evaluate(random_xdata, random_ydata)), True) # assert shape correct as expected np.testing.assert_array_equal(prediction.shape, random_ydata.shape) np.testing.assert_array_equal(jacobian.shape, [random_xdata[:2].shape[0], random_ydata.shape[1], random_xdata.shape[1]]) np.testing.assert_array_equal(hessian.shape, [random_xdata[:2].shape[0], random_ydata.shape[1], random_xdata.shape[1]]) # hessian approx and exact result should have the same shape np.testing.assert_array_equal(hessian_full_approx.shape, hessian_full_exact.shape) # save weight and model again neuralnet.save(name='apogee_cnn') neuralnet.save_weights('save_weights_test.h5') # load the model again neuralnet_loaded = load_folder("apogee_cnn") neuralnet_loaded.plot_dense_stats() # assert has model without training because this is a trained model self.assertEqual(neuralnet_loaded.has_model, True) # fine tune test prediction_loaded = neuralnet_loaded.test(random_xdata) # ApogeeCNN is deterministic check again np.testing.assert_array_equal(prediction, prediction_loaded) # Fine tuning test neuralnet_loaded.max_epochs = 1 neuralnet_loaded.callbacks = ErrorOnNaN() neuralnet_loaded.train(random_xdata, random_ydata) prediction_loaded = neuralnet_loaded.test(random_xdata) # prediction should not be equal after fine-tuning self.assertRaises(AssertionError, np.testing.assert_array_equal, prediction, prediction_loaded)
def test_apogee_cnn(self): """ Test ApogeeCNN models - training, testing, evaluation - basic astroNN model method """ print("======ApogeeCNN======") # setup model instance neuralnet = ApogeeCNN() print(neuralnet) # assert no model before training self.assertEqual(neuralnet.has_model, False) neuralnet.max_epochs = 5 # for quick result neuralnet.callbacks = ErrorOnNaN( ) # Raise error and fail the test if Nan neuralnet.targetname = ['logg', 'feh'] neuralnet.train(xdata, ydata) # training neuralnet.train_on_batch(xdata[:64], ydata[:64]) # single batch fine-tuning test # self.assertEqual(neuralnet.uses_learning_phase, True) # Assert ApogeeCNN uses learning phase (bc of Dropout) # test basic astroNN model method neuralnet.get_weights() neuralnet.summary() output_shape = neuralnet.output_shape input_shape = neuralnet.input_shape neuralnet.get_config() neuralnet.save_weights( 'save_weights_test.h5') # save astroNN weight only neuralnet.plot_dense_stats() neuralnet.plot_model() prediction = neuralnet.test(xdata) mape = np.median( np.abs(prediction[neuralnet.val_idx] - ydata[neuralnet.val_idx]) / ydata[neuralnet.val_idx], axis=0) self.assertEqual(np.all(0.15 > mape), True) # assert less than 15% error jacobian = neuralnet.jacobian(xdata[:5]) # assert shape correct as expected np.testing.assert_array_equal(prediction.shape, ydata.shape) np.testing.assert_array_equal( jacobian.shape, [xdata[:5].shape[0], ydata.shape[1], xdata.shape[1]]) hessian = neuralnet.hessian(xdata[:5], mean_output=True) np.testing.assert_array_equal( hessian.shape, [ydata.shape[1], xdata.shape[1], xdata.shape[1]]) # make sure raised if data dimension not as expected self.assertRaises(ValueError, neuralnet.jacobian, np.atleast_3d(xdata[:3])) # make sure evaluate run in testing phase instead of learning phase # ie no Dropout which makes model deterministic self.assertEqual( np.all( neuralnet.evaluate(xdata, ydata) == neuralnet.evaluate( xdata, ydata)), True) # save weight and model again neuralnet.save(name='apogee_cnn') neuralnet.save_weights('save_weights_test.h5') # load the model again neuralnet_loaded = load_folder("apogee_cnn") neuralnet_loaded.plot_dense_stats() # assert has model without training because this is a trained model self.assertEqual(neuralnet_loaded.has_model, True) # fine tune test prediction_loaded = neuralnet_loaded.test(xdata) # ApogeeCNN is deterministic check again np.testing.assert_array_equal(prediction, prediction_loaded) # Fine tuning test neuralnet_loaded.max_epochs = 5 neuralnet_loaded.callbacks = ErrorOnNaN() neuralnet_loaded.train(xdata, ydata) prediction_loaded = neuralnet_loaded.test(xdata[neuralnet.val_idx]) # prediction should not be equal after fine-tuning self.assertRaises(AssertionError, np.testing.assert_array_equal, prediction, prediction_loaded)
def test_apogee_cnn(self): # Data preparation, keep the data size large (>800 data points to prevent issues) random_xdata = np.random.normal(0, 1, (200, 1024)) random_ydata = np.random.normal(0, 1, (200, 2)) # ApogeeCNN print("======ApogeeCNN======") neuralnet = ApogeeCNN() self.assertEqual(neuralnet.has_model, False) neuralnet.max_epochs = 1 neuralnet.callbacks = ErrorOnNaN() neuralnet.train(random_xdata, random_ydata) self.assertEqual(neuralnet.uses_learning_phase, True) neuralnet.get_weights() neuralnet.get_config() neuralnet.save_weights('save_weights_test.h5') neuralnet.summary() output_shape = neuralnet.output_shape input_shape = neuralnet.input_shape prediction = neuralnet.test(random_xdata) jacobian = neuralnet.jacobian(random_xdata[:3]) hessian = neuralnet.hessian_diag(random_xdata[:2]) hessian_full_approx = neuralnet.hessian(random_xdata[:2], method='approx') hessian_full_exact = neuralnet.hessian(random_xdata[:2], method='exact') self.assertRaises(ValueError, neuralnet.jacobian, np.atleast_3d(random_xdata[:3])) # make sure evaluate run in testing phase instead of learning phase # ie no Dropout which makes model deterministic self.assertEqual( np.all( neuralnet.evaluate(random_xdata, random_ydata) == neuralnet.evaluate(random_xdata, random_ydata)), True) np.testing.assert_array_equal(prediction.shape, random_ydata.shape) np.testing.assert_array_equal(jacobian.shape, [ random_xdata[:3].shape[0], random_ydata.shape[1], random_xdata.shape[1] ]) np.testing.assert_array_equal(hessian.shape, [ random_xdata[:2].shape[0], random_ydata.shape[1], random_xdata.shape[1] ]) neuralnet.save(name='apogee_cnn') neuralnet.save_weights('save_weights_test.h5') neuralnet_loaded = load_folder("apogee_cnn") self.assertEqual(neuralnet_loaded.has_model, True) neuralnet_loaded.max_epochs = 1 neuralnet_loaded.callbacks = ErrorOnNaN() prediction_loaded = neuralnet_loaded.test(random_xdata) # Apogee_CNN is deterministic np.testing.assert_array_equal(prediction, prediction_loaded) # Fine tuning test neuralnet_loaded.train(random_xdata, random_ydata) prediction_loaded = neuralnet_loaded.test(random_xdata) # prediction should not be equal after fine-tuning self.assertRaises(AssertionError, np.testing.assert_array_equal, prediction, prediction_loaded)