def setUp(self): # define prior and model sigma = Uniform([[10], [20]]) mu = Normal([0, 1]) self.Y = Normal([mu, sigma]) # define backend self.backend = Backend() # define statistics self.statistics_cal = Identity(degree=3, cross=False) if has_torch: # Initialize statistics learning self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=100, n_samples_per_param=1, seed=1, n_epochs=10, scale_samples=False) # with sample scaler: self.statisticslearning_with_scaler = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=100, n_samples_per_param=1, seed=1, n_epochs=10, scale_samples=True)
class SemiautomaticNNTests(unittest.TestCase): def setUp(self): # define prior and model sigma = Uniform([[10], [20]]) mu = Normal([0, 1]) self.Y = Normal([mu, sigma]) # define backend self.backend = Backend() # define statistics self.statistics_cal = Identity(degree=3, cross=False) if has_torch: # Initialize statistics learning self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=100, n_samples_per_param=1, seed=1, n_epochs=10) def test_initialization(self): if not has_torch: self.assertRaises(ImportError, SemiautomaticNN, [self.Y], self.statistics_cal, self.backend) def test_transformation(self): if has_torch: # Transform statistics extraction self.new_statistics_calculator = self.statisticslearning.get_statistics( ) # Simulate observed data Obs = Normal([2, 4]) y_obs = Obs.forward_simulate(Obs.get_input_values(), 1)[0].tolist() extracted_statistics = self.new_statistics_calculator.statistics( y_obs) self.assertEqual(np.shape(extracted_statistics), (1, 2)) self.assertRaises(RuntimeError, self.new_statistics_calculator.statistics, [np.array([1, 2])])
def infer_parameters(steps=2, n_sample=50, n_samples_per_param=1, logging_level=logging.WARN): """Perform inference for this example. Parameters ---------- steps : integer, optional Number of iterations in the sequential PMCABC algorithm ("generations"). The default value is 3 n_samples : integer, optional Number of posterior samples to generate. The default value is 250. n_samples_per_param : integer, optional Number of data points in each simulated data set. The default value is 10. Returns ------- abcpy.output.Journal A journal containing simulation results, metadata and optionally intermediate results. """ logging.basicConfig(level=logging_level) # define backend # Note, the dummy backend does not parallelize the code! from abcpy.backends import BackendDummy as Backend backend = Backend() # define observation for true parameters mean=170, std=15 height_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084, 172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017, 183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515, 197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633, 165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537, 206.22458790620766, 220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275, 171.63761180867033, 210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235, 197.42448680731226, 165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519, 185.30223966014586, 152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741, 250.19273595481803, 148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021, 138.24716809523139, 179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626, 188.27229523693822, 202.67075179617672, 211.75963110985992, 217.45423324370509] # define prior from abcpy.continuousmodels import Uniform mu = Uniform([[150], [200]], name="mu") sigma = Uniform([[5], [25]], name="sigma") # define the model from abcpy.continuousmodels import Normal height = Normal([mu, sigma], ) # 1) generate simulations from prior from abcpy.inferences import DrawFromPrior draw_from_prior = DrawFromPrior([height], backend=backend) # notice the use of the `.sample_par_sim_pairs` method rather than `.sample` to obtain data suitably formatted # for the summary statistics learning routines parameters, simulations = draw_from_prior.sample_par_sim_pairs(100, n_samples_per_param=1) # if you want to use the test loss to do early stopping in the training: parameters_val, simulations_val = draw_from_prior.sample_par_sim_pairs(100, n_samples_per_param=1) # discard the mid dimension (n_samples_per_param, as the StatisticsLearning classes use that =1) simulations = simulations.reshape(simulations.shape[0], simulations.shape[2]) simulations_val = simulations_val.reshape(simulations_val.shape[0], simulations_val.shape[2]) # 2) now train the NNs with the different methods with the generated data from abcpy.statistics import Identity identity = Identity() # to apply before computing the statistics logging.info("semiNN") from abcpy.statisticslearning import SemiautomaticNN, TripletDistanceLearning semiNN = SemiautomaticNN([height], identity, backend=backend, parameters=parameters, simulations=simulations, parameters_val=parameters_val, simulations_val=simulations_val, early_stopping=True, # early stopping seed=1, n_epochs=10, scale_samples=False, use_tqdm=False) logging.info("triplet") triplet = TripletDistanceLearning([height], identity, backend=backend, parameters=parameters, simulations=simulations, parameters_val=parameters_val, simulations_val=simulations_val, early_stopping=True, # early stopping seed=1, n_epochs=10, scale_samples=True, use_tqdm=False) # 3) save and re-load NNs: # get the statistics from the already fit StatisticsLearning object 'semiNN': learned_seminn_stat = semiNN.get_statistics() learned_triplet_stat = triplet.get_statistics() # this has a save net method: learned_seminn_stat.save_net("seminn_net.pth") # if you used `scale_samples=True` in learning the NNs, need to provide a path where pickle stores the scaler too: learned_triplet_stat.save_net("triplet_net.pth", path_to_scaler="scaler.pkl") # to reload: need to use the Neural Embedding statistics fromFile; this needs to know which kind of NN it is using; # need therefore to pass either the input/output size (it data size and number parameters) or the network class if # that was specified explicitly in the StatisticsLearning class. Check the docstring for NeuralEmbedding.fromFile # for more details. from abcpy.statistics import NeuralEmbedding learned_seminn_stat_loaded = NeuralEmbedding.fromFile("seminn_net.pth", input_size=1, output_size=2) learned_triplet_stat_loaded = NeuralEmbedding.fromFile("triplet_net.pth", input_size=1, output_size=2, path_to_scaler="scaler.pkl") # 4) you can optionally rescale the different summary statistics be their standard deviation on a reference dataset # of simulations. To do this, it is enough to pass at initialization the reference dataset, and the rescaling will # be applied every time the statistics is computed on some simulation or observation. learned_triplet_stat_loaded = NeuralEmbedding.fromFile("triplet_net.pth", input_size=1, output_size=2, path_to_scaler="scaler.pkl", reference_simulations=simulations_val) # 5) perform inference # define distance from abcpy.distances import Euclidean distance_calculator = Euclidean(learned_seminn_stat_loaded) # define kernel from abcpy.perturbationkernel import DefaultKernel kernel = DefaultKernel([mu, sigma]) # define sampling scheme from abcpy.inferences import PMCABC sampler = PMCABC([height], [distance_calculator], backend, kernel, seed=1) eps_arr = np.array([500]) # starting value of epsilon; the smaller, the slower the algorithm. # at each iteration, take as epsilon the epsilon_percentile of the distances obtained by simulations at previous # iteration from the observation epsilon_percentile = 10 journal = sampler.sample([height_obs], steps, eps_arr, n_sample, n_samples_per_param, epsilon_percentile) return journal
def infer_parameters(steps=3, n_sample=250, n_samples_per_param=10, logging_level=logging.WARN): """Perform inference for this example. Parameters ---------- steps : integer, optional Number of iterations in the sequential PMCABC algoritm ("generations"). The default value is 3 n_samples : integer, optional Number of posterior samples to generate. The default value is 250. n_samples_per_param : integer, optional Number of data points in each simulated data set. The default value is 10. Returns ------- abcpy.output.Journal A journal containing simulation results, metadata and optionally intermediate results. """ logging.basicConfig(level=logging_level) # define backend # Note, the dummy backend does not parallelize the code! from abcpy.backends import BackendDummy as Backend backend = Backend() # define observation for true parameters mean=170, std=15 height_obs = [ 160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084, 172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017, 183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515, 197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633, 165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537, 206.22458790620766, 220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275, 171.63761180867033, 210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235, 197.42448680731226, 165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519, 185.30223966014586, 152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741, 250.19273595481803, 148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021, 138.24716809523139, 179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626, 188.27229523693822, 202.67075179617672, 211.75963110985992, 217.45423324370509 ] # define prior from abcpy.continuousmodels import Uniform mu = Uniform([[150], [200]], name="mu") sigma = Uniform([[5], [25]], name="sigma") # define the model from abcpy.continuousmodels import Normal height = Normal([mu, sigma], ) # define statistics from abcpy.statistics import Identity statistics_calculator = Identity(degree=3, cross=True) # Learn the optimal summary statistics using Semiautomatic summary selection from abcpy.statisticslearning import Semiautomatic statistics_learning = Semiautomatic([height], statistics_calculator, backend, n_samples=1000, n_samples_per_param=1, seed=1) # Redefine the statistics function new_statistics_calculator = statistics_learning.get_statistics() # Learn the optimal summary statistics using SemiautomaticNN summary selection; # we use 200 samples as a validation set for early stopping: from abcpy.statisticslearning import SemiautomaticNN statistics_learning = SemiautomaticNN([height], statistics_calculator, backend, n_samples=1000, n_samples_val=200, n_samples_per_param=1, seed=1, early_stopping=True) # Redefine the statistics function new_statistics_calculator = statistics_learning.get_statistics() # define distance from abcpy.distances import Euclidean distance_calculator = Euclidean(new_statistics_calculator) # define kernel from abcpy.perturbationkernel import DefaultKernel kernel = DefaultKernel([mu, sigma]) # define sampling scheme from abcpy.inferences import PMCABC sampler = PMCABC([height], [distance_calculator], backend, kernel, seed=1) eps_arr = np.array([ 500 ]) # starting value of epsilon; the smaller, the slower the algorithm. # at each iteration, take as epsilon the epsilon_percentile of the distances obtained by simulations at previous # iteration from the observation epsilon_percentile = 10 journal = sampler.sample([height_obs], steps, eps_arr, n_sample, n_samples_per_param, epsilon_percentile) return journal
def test_errors(self): if has_torch: with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, parameters=np.ones((100, 1))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, simulations=np.ones((100, 1))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, simulations=np.ones((100, 1, 3))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, parameters=np.ones((100, 1, 2))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, simulations=np.ones((100, 1)), parameters=np.zeros((99, 1))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, parameters_val=np.ones((100, 1))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, simulations_val=np.ones((100, 1))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, simulations_val=np.ones((100, 1, 3))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, parameters_val=np.ones((100, 1, 2))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, simulations_val=np.ones((100, 1)), parameters_val=np.zeros((99, 1))) with self.assertRaises(TypeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, parameters=[i for i in range(10)], simulations=[i for i in range(10)]) with self.assertRaises(TypeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, parameters_val=[i for i in range(10)], simulations_val=[i for i in range(10)])
def infer_parameters(): # define backend # Note, the dummy backend does not parallelize the code! from abcpy.backends import BackendDummy as Backend backend = Backend() # define observation for true parameters mean=170, std=15 height_obs = [ 160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084, 172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017, 183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515, 197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633, 165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537, 206.22458790620766, 220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275, 171.63761180867033, 210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235, 197.42448680731226, 165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519, 185.30223966014586, 152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741, 250.19273595481803, 148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021, 138.24716809523139, 179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626, 188.27229523693822, 202.67075179617672, 211.75963110985992, 217.45423324370509 ] # define prior from abcpy.continuousmodels import Uniform mu = Uniform([[150], [200]], ) sigma = Uniform([[5], [25]], ) # define the model from abcpy.continuousmodels import Normal height = Normal([mu, sigma], ) # define statistics from abcpy.statistics import Identity statistics_calculator = Identity(degree=3, cross=True) # Learn the optimal summary statistics using Semiautomatic summary selection from abcpy.statisticslearning import Semiautomatic statistics_learning = Semiautomatic([height], statistics_calculator, backend, n_samples=1000, n_samples_per_param=1, seed=1) # Redefine the statistics function new_statistics_calculator = statistics_learning.get_statistics() # Learn the optimal summary statistics using SemiautomaticNN summary selection from abcpy.statisticslearning import SemiautomaticNN statistics_learning = SemiautomaticNN([height], statistics_calculator, backend, n_samples=1000, n_samples_per_param=1, seed=1) # Redefine the statistics function new_statistics_calculator = statistics_learning.get_statistics() # define distance from abcpy.distances import Euclidean distance_calculator = Euclidean(new_statistics_calculator) # define kernel from abcpy.perturbationkernel import DefaultKernel kernel = DefaultKernel([mu, sigma]) # define sampling scheme from abcpy.inferences import PMCABC sampler = PMCABC([height], [distance_calculator], backend, kernel, seed=1) # sample from scheme T, n_sample, n_samples_per_param = 3, 10, 10 eps_arr = np.array([500]) epsilon_percentile = 10 journal = sampler.sample([height_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile) return journal
class SemiautomaticNNTests(unittest.TestCase): def setUp(self): # define prior and model sigma = Uniform([[10], [20]]) mu = Normal([0, 1]) self.Y = Normal([mu, sigma]) # define backend self.backend = Backend() # define statistics self.statistics_cal = Identity(degree=3, cross=False) if has_torch: # Initialize statistics learning self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=100, n_samples_val=100, n_samples_per_param=1, seed=1, n_epochs=2, scale_samples=False, use_tqdm=False) self.statisticslearning2 = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=10, n_samples_val=10, n_samples_per_param=1, seed=1, n_epochs=5, scale_samples=False, use_tqdm=False) # with sample scaler: self.statisticslearning_with_scaler = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=100, n_samples_per_param=1, seed=1, n_epochs=2, scale_samples=True, use_tqdm=False) def test_initialization(self): if not has_torch: self.assertRaises(ImportError, SemiautomaticNN, [self.Y], self.statistics_cal, self.backend) def test_transformation(self): if has_torch: # Transform statistics extraction self.new_statistics_calculator = self.statisticslearning.get_statistics( ) self.new_statistics_calculator_with_scaler = self.statisticslearning_with_scaler.get_statistics( ) # Simulate observed data Obs = Normal([2, 4]) y_obs = Obs.forward_simulate(Obs.get_input_values(), 1)[0].tolist() extracted_statistics = self.new_statistics_calculator.statistics( y_obs) self.assertEqual(np.shape(extracted_statistics), (1, 2)) self.assertRaises(RuntimeError, self.new_statistics_calculator.statistics, [np.array([1, 2])]) extracted_statistics = self.new_statistics_calculator_with_scaler.statistics( y_obs) self.assertEqual(np.shape(extracted_statistics), (1, 2)) self.assertRaises( RuntimeError, self.new_statistics_calculator_with_scaler.statistics, [np.array([1, 2])]) def test_errors(self): if has_torch: with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, parameters=np.ones((100, 1))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, embedding_net=createDefaultNN(1, 2)) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, simulations=np.ones((100, 1))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, simulations=np.ones((100, 1, 3))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, parameters=np.ones((100, 1, 2))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, simulations=np.ones((100, 1)), parameters=np.zeros((99, 1))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, parameters_val=np.ones((100, 1))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, simulations_val=np.ones((100, 1))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, simulations_val=np.ones((100, 1, 3))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, parameters_val=np.ones((100, 1, 2))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, simulations_val=np.ones((100, 1)), parameters_val=np.zeros((99, 1))) with self.assertRaises(TypeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, parameters=[i for i in range(10)], simulations=[i for i in range(10)]) with self.assertRaises(TypeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, parameters_val=[i for i in range(10)], simulations_val=[i for i in range(10)]) with self.assertRaises(RuntimeError): self.statisticslearning2.test_losses = [4, 2, 1] self.statisticslearning2.plot_losses() with self.assertRaises(NotImplementedError): self.statisticslearning.plot_losses(which_losses="foo") def test_plots(self): if has_torch: self.statisticslearning.plot_losses() self.statisticslearning.plot_losses(which_losses="train") self.statisticslearning.plot_losses(which_losses="test")
def test_errors(self): if has_torch: with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, parameters=np.ones((100, 1))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, embedding_net=createDefaultNN(1, 2)) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, simulations=np.ones((100, 1))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, simulations=np.ones((100, 1, 3))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, parameters=np.ones((100, 1, 2))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, simulations=np.ones((100, 1)), parameters=np.zeros((99, 1))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, parameters_val=np.ones((100, 1))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, simulations_val=np.ones((100, 1))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, simulations_val=np.ones((100, 1, 3))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, parameters_val=np.ones((100, 1, 2))) with self.assertRaises(RuntimeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, simulations_val=np.ones((100, 1)), parameters_val=np.zeros((99, 1))) with self.assertRaises(TypeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, parameters=[i for i in range(10)], simulations=[i for i in range(10)]) with self.assertRaises(TypeError): self.statisticslearning = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1, parameters_val=[i for i in range(10)], simulations_val=[i for i in range(10)]) with self.assertRaises(RuntimeError): self.statisticslearning2.test_losses = [4, 2, 1] self.statisticslearning2.plot_losses() with self.assertRaises(NotImplementedError): self.statisticslearning.plot_losses(which_losses="foo")
if train_save_NN: # # Define backend # from abcpy.backends import BackendDummy # backend = BackendDummy() if fake: parameters = np.load('Data/Pilots/simulation_pilot_fake.npz')['parameters'] simulations = np.load('Data/Pilots/simulation_pilot_fake.npz')['simulations'] else: parameters = np.load('Data/ailots/simulation_pilot_'+str(whichobs)+'.npz')['parameters'] simulations = np.load('Data/Pilots/simulation_pilot_'+str(whichobs)+'.npz')['simulations'] print(parameters.shape, simulations.shape) #now train the NNs with the different methods with the generated data print("semiNN") semiNN = SemiautomaticNN([PD], identity, backend=backend, parameters=parameters, simulations=simulations, early_stopping=False, batch_size=32,# early stopping seed=1, n_epochs=1000, lr=1e-4, scale_samples=False) #1000 print("triplet") triplet = TripletDistanceLearning([PD], identity, backend=backend, parameters=parameters, simulations=simulations, early_stopping=False, batch_size=32, # early stopping seed=1, n_epochs=2000, lr=1e-3, scale_samples=False) # 2000 # get the statistics from the StatisticsLearning object: learned_seminn_stat = semiNN.get_statistics() learned_triplet_stat = triplet.get_statistics() # saving the learned net if fake: learned_seminn_stat.save_net("Data/Pilots/seminn_net_fake.pth") learned_triplet_stat.save_net("Data/Pilots/triplet_net_fake.pth") else: learned_seminn_stat.save_net("Data/Pilots/seminn_net_"+str(whichobs)+".pth") learned_triplet_stat.save_net("Data/Pilots/triplet_net_"+str(whichobs)+".pth")