def test_boston_load_does_not_affect_global_rng(fake_downloaded_boston_path): np.random.seed(1337) before = np.random.randint(0, 100, size=10) np.random.seed(1337) boston_housing.load_data(path=fake_downloaded_boston_path, seed=9876) after = np.random.randint(0, 100, size=10) assert np.array_equal(before, after)
def testModel(self): print("=======================================\n testModel") # data preparation; (x_train, y_train), (x_test, y_test) = boston_housing.load_data() in_scaler = StandardScaler() out_scaler = StandardScaler() in_scaler.fit(x_train) x_train = in_scaler.transform(x_train) x_test = in_scaler.transform(x_test) y_train = y_train.reshape((x_train.shape[0], 1)) y_test = y_test.reshape((x_test.shape[0], 1)) out_scaler.fit(y_train) y_train = out_scaler.transform(y_train) y_test = out_scaler.transform(y_test) # NN handler; qt = BostonHousingComplexTest(64) qt.visualize(torch.from_numpy(x_test).float()) qt.epoch( np.array(x_train, dtype=np.float32), np.array(y_train, dtype=np.float32), np.array(x_test, dtype=np.float32), np.array(y_test, dtype=np.float32), epochs=2000, ) qt.saveModel() self.assertLessEqual(qt._stats["loss_epoch"][-1], 0.5) print(" ", qt._stats["loss_epoch"][-1], 0.5)
def __init__(self, *args, **kwargs): super(BostonHousing, self).__init__('regression', *args, **kwargs) (x_train, y_train), (x_test, y_test) = boston_housing.load_data() y_train = np.hstack( [y_train.reshape(-1, 1), -np.ones(shape=[len(y_train), 1])]) y_test = np.hstack( [y_test.reshape(-1, 1), -np.ones(shape=[len(y_test), 1])]) xscaler = StandardScaler().fit(x_train) x_train = xscaler.transform(x_train) x_test = xscaler.transform(x_test) self.xscaler = xscaler yscaler = StandardScaler().fit(y_train) y_train = yscaler.transform(y_train) y_test = yscaler.transform(y_test) self.yscaler = yscaler self.input_shape = x_train.shape[1:] self.output_size = 2 split = int(len(x_train) * 0.8) self.x_train = x_train[:split] self.y_train = y_train[:split] self.x_val = x_train[split:] self.y_val = y_train[split:] self.x_test = x_test self.y_test = y_test print(self.x_train.shape, self.y_train.shape) print(self.x_val.shape, self.y_val.shape) print(self.x_test.shape, self.y_test.shape)
def mlp(epochs: int): set_seed(42) (x_train, y_train), (x_test, y_test) = boston_housing.load_data() model = Sequential([ InputLayer(input_shape=(x_train.shape[1], )), Dense(10, input_shape=(x_train.shape[1], ), activation="relu"), Dense(10, activation="relu"), Dense(10, activation="relu"), Dense(10, activation="relu"), Dropout(0.2), Dense(1, activation="relu") ]) model.compile(optimizer="nadam", loss="mse") history = model.fit(x_train, y_train, validation_data=(x_test, y_test), epochs=epochs, batch_size=100, shuffle=True).history model.save("model.h5") pd.DataFrame(history).to_csv("history.csv") #plot_history(history) plt.savefig("history.png")
def import_boston_housing(): (x_train, y_train), (x_test, y_test) = boston_housing.load_data() np.save(boston_100_dir + 'x_train', x_train) np.save(boston_100_dir + 'y_train', y_train) np.save(boston_100_dir + 'x_test', x_test) np.save(boston_100_dir + 'y_test', y_test)
def boston_housing_to_hdf5(file_name): if os.path.exists(file_name): return (x_train, y_train), (x_test, y_test) = boston_housing.load_data() print('x_train shape:', x_train.shape) print(x_train.shape[0], 'train samples') print(x_test.shape[0], 'test samples') y_train = keras.utils.to_categorical(y_train, num_classes) y_test = keras.utils.to_categorical(y_test, num_classes) x_train = x_train.astype('float64') x_test = x_test.astype('float64') x = numpy.concatenate((x_train, x_test)) y = numpy.concatenate((y_train, y_test)) numpy.random.shuffle(x) numpy.random.shuffle(y) with h5py.File(file_name, 'w') as f: f.create_dataset('x', data=x, compression='gzip') f.create_dataset('y', data=y, compression='gzip')
def get_data_boston_housing(self): (x_train, y_train), (x_test, y_test) = boston_housing.load_data() mean, std = np.mean(x_train, axis=0), np.std(x_train, axis=0) x_train = (x_train - mean) / std x_test = (x_test - mean) / std return (x_train, np.squeeze(y_train)), (x_test, np.squeeze(y_test)), \ (x_train.shape[-1],), 1
def get_data(): (train_data, trian_targets), (test_data, test_targets) = boston_housing.load_data() train_data, mean, std = normal_data(train_data) test_data = normal_data(test_data, mean, std) return train_data, trian_targets, test_data, test_targets
def main(): (train_data, train_targets), (test_data, test_targets) = boston_housing.load_data() # normalize data: subtract mean of the feature and divide by standard deviation mean = train_data.mean(axis=0) train_data -= mean std = train_data.std(axis=0) train_data /= std test_data -= mean test_data /= std # using K-fold validation due to low number of training examples k = 4 num_val_samples = len(train_data) // k num_epochs = 500 all_mae_histories = [] for i in range(k): print('processing fold #', i) val_data = train_data[i * num_val_samples:(i + 1) * num_val_samples] val_targets = train_targets[i * num_val_samples:(i + 1) * num_val_samples] partial_train_data = np.concatenate([ train_data[:i * num_val_samples], train_data[(i + 1) * num_val_samples:] ], axis=0) partial_train_targets = np.concatenate([ train_targets[:i * num_val_samples], train_targets[(i + 1) * num_val_samples:] ], axis=0) # cant keep using the same model, new model per fold model = build_model(train_data) history = model.fit(partial_train_data, partial_train_targets, validation_data=(val_data, val_targets), epochs=num_epochs, batch_size=1, verbose=0) mae_history = history.history['val_mae'] all_mae_histories.append(mae_history) # compute the average of the per-epoch MAE scores (mean absolute error) average_mae_history = [ np.mean([x[i] for x in all_mae_histories]) for i in range(num_epochs) ] smoothed_mae_history = smooth_curve(average_mae_history[10:]) plt.plot(range(1, len(smoothed_mae_history) + 1), smoothed_mae_history) plt.xlabel('Epochs') plt.ylabel('Validation MAE') plt.show()
def data_preparing(self): (train_data, train_targets), (test_data, test_targets) = boston_housing.load_data() train_data, test_data = self.normalize(train_data, test_data) return (train_data, train_targets), (test_data, test_targets)
def test_boston_housing(): # only run data download tests 20% of the time # to speed up frequent testing random.seed(time.time()) if random.random() > 0.8: (x_train, y_train), (x_test, y_test) = boston_housing.load_data() assert len(x_train) == len(y_train) assert len(x_test) == len(y_test)
def __init__(self, **kwargs): (x_train, y_train), (x_test, y_test) = boston_housing.load_data() TrainExperiment.__init__(self, x_train, y_train, x_test, y_test, task='regression', **kwargs)
def load_data_boston(workpath=''): """ 加载波士顿数据集 :return: """ from keras.datasets import boston_housing (train_data, train_target), (test_data, test_target) = boston_housing.load_data() logger.info('加载数据集训练集:{}'.format(len(train_data))) logger.info('加载的测试集数:{}'.format(len(test_data))) return (train_data, train_target), (test_data, test_target)
def load_data(): (x_train, y_train), (x_test, y_test) = boston_housing.load_data() x = np.vstack((x_train, x_test)) y = np.concatenate((y_train, y_test)) x = StandardScaler().fit_transform(x) y = StandardScaler().fit_transform(y.reshape(-1, 1)) x_train = x[1:401, :] x_test = x[401:, :] y_train = y[1:401, :] y_test = y[401:, :] return (x_train, y_train), (x_test, y_test)
def train(): (train_data, train_targets), (test_data, test_targets) = boston_housing.load_data() mean = train_data.mean(axis=0) train_data -= mean std = train_data.std(axis=0) train_data /= std test_data -= mean test_data /= std k = 4 num_val_samples = len(train_data) // k num_epochs = 500 all_mae_histories = [] for i in range(k): print('processing fold #', i) # Prepare the validation data: data from partition # k val_data = train_data[i * num_val_samples:(i + 1) * num_val_samples] val_targets = train_targets[i * num_val_samples:(i + 1) * num_val_samples] # Prepare the training data: data from all other partitions partial_train_data = np.concatenate([ train_data[:i * num_val_samples], train_data[(i + 1) * num_val_samples:] ], axis=0) partial_train_targets = np.concatenate([ train_targets[:i * num_val_samples], train_targets[(i + 1) * num_val_samples:] ], axis=0) # Build the Keras model (already compiled) model = build_model() # Train the model (in silent mode, verbose=0) history = model.fit(partial_train_data, partial_train_targets, validation_data=(val_data, val_targets), epochs=num_epochs, batch_size=1, verbose=0) # Evaluate the model on the validation data # val_mse, val_mae = model.evaluate(val_data, val_targets, verbose=0) mae_history = history.history['val_mean_absolute_error'] all_mae_histories.append(val_mae) average_mae_history = [ np.mean([x[i] for x in all_mae_histories]) for i in range(num_epochs) ] return average_mae_history
def data_handle(): (train_data, train_targets), (test_data, test_targets) = boston_housing.load_data() mean = train_data.mean(axis=0) train_data -= mean std = train_data.std(axis=0) train_data /= std test_data -= mean test_data /= std return (train_data, test_data, train_targets, test_targets)
def load_data(self, train_size: int = None, test_size: int = None) -> (tuple, tuple): self._logger.info("Loading Boston housing prices data.") (x_train, y_train), (x_test, y_test) = boston_housing.load_data() if train_size is not None: x_train, y_train = x_train[:train_size], y_train[:train_size] if test_size is not None: x_test, y_test = x_test[:test_size], y_test[:test_size] self._logger.info("Done loading data.") return (x_train, y_train), (x_test, y_test)
def main(): (train_data, train_targets), (test_data, test_targets) = \ boston_housing.load_data() mean = train_data.mean(axis=0) train_data -= mean std = train_data.std(axis=0) train_data /= std # quantities used for normalizing are computed using the training data test_data -= mean test_data /= std k = 4 num_val_samples = len(train_data) // k num_epochs = 500 all_mae_histories = [] for i in range(k): print('processing fold #', i) val_data = train_data[i * num_val_samples: (i+1) * num_val_samples] val_targets = train_targets[i * num_val_samples: (i+1) * num_val_samples] partial_train_data = np.concatenate( [train_data[:i * num_val_samples], train_data[(i+1) * num_val_samples:]], axis=0) partial_train_targets = np.concatenate( [train_targets[:i * num_val_samples], train_targets[(i+1) * num_val_samples:]], axis=0) model = build_model(input_shape=(train_data.shape[1],)) history = model.fit(partial_train_data, partial_train_targets, validation_data=(val_data, val_targets), epochs=num_epochs, batch_size=1, verbose=1) #val_mse, val_mae = model.evaluate(val_data, val_targets, verbose=0) #all_scores.append(val_mae) mae_history = history.history['val_mean_absolute_error'] all_mae_histories.append(mae_history) print(all_mae_histories) print(np.mean(all_mae_histories)) average_mae_history = [np.mean([x[i] for x in all_mae_histories]) for i in range(num_epochs)] plt.plot(range(1, len(average_mae_history) + 1), average_mae_history) plt.xlabel('Epochs') plt.ylabel('Validation MAE') plt.show()
def prepare_boston(): (x_train, y_train), (x_test, y_test) = boston_housing.load_data() scaler_x = MinMaxScaler() scaler_x.fit(x_train) x_train = scaler_x.transform(x_train) x_test = scaler_x.transform(x_test) scaler_y = MinMaxScaler() scaler_y.fit(y_train[:, np.newaxis]) y_train = scaler_y.transform(y_train[:, np.newaxis]) y_test = scaler_y.transform(y_test[:, np.newaxis]) return x_train, x_test, y_train, y_test
def loadDataset(dataset, normalize=True): #seeding for reproducibility seed = 8 np.random.seed(seed) #loads the data if dataset == "mnist": from keras.datasets import mnist (XTrain, yTrain), (XTest, yTest) = mnist.load_data() #XTrain = XTrain.reshape(XTrain.shape[0], 1, 28, 28).astype('float32') #XTest = XTest.reshape(XTest.shape[0], 1, 28, 28).astype('float32') num_pixels = XTrain.shape[1] * XTrain.shape[2] XTrain = XTrain.reshape(XTrain.shape[0], num_pixels).astype('float32') XTest = XTest.reshape(XTest.shape[0], num_pixels).astype('float32') elif dataset == "cifar10": from keras.datasets import cifar10 (XTrain, yTrain), (XTest, yTest) = cifar10.load_data() XTrain=XTrain.astype('float32') XTest=XTest.astype('float32') elif dataset == "cifar100": from keras.datasets import cifar100 (XTrain, yTrain), (XTest, yTest) = cifar100.load_data() XTrain=XTrain.astype('float32') XTest=XTest.astype('float32') elif dataset == "fashionMNIST": from keras.datasets import fashion_mnist (XTrain, yTrain), (XTest, yTest) = fashion_mnist.load_data() elif dataset == "imdb": from keras.datasets import imdb (XTrain, yTrain), (XTest, yTest) = imdb.load_data() elif dataset == "reuters": from keras.datasets import reuters (XTrain, yTrain), (XTest, yTest) = reuters.load_data() elif dataset == "bostonHousing": from keras.datasets import boston_housing (XTrain, yTrain), (XTest, yTest) = boston_housing.load_data() else: print("ERROR: Need functionality for " + dataset) return 0, 0, 0, 0, 0 #one hot encode the outputs and set the number of classes yTrain = np_utils.to_categorical(yTrain) yTest = np_utils.to_categorical(yTest) numClasses = yTest.shape[1] if normalize==True: XTrain /= 255 XTest /= 255 return XTrain, yTrain, XTest, yTest, numClasses
def get_dataset(): # ボストンハウスのデータのダウンロードまたは読み込み。 # 訓練と試験用に分割する。 分割の割合はGBR.pyと同じにしてあります (train_data, train_targets), (test_data, test_targets) = boston_housing.load_data(test_split=0.1, seed=13) # データを 平均0、分散1に変換する(正規化) mean = train_data.mean(axis=0) train_data -= mean std = train_data.std(axis=0) train_data /= std test_data -= mean test_data /= std return (train_data, train_targets), (test_data, test_targets)
def bostonhousing(): from keras.datasets import boston_housing (x_train, y_train), (x_test, y_test) = boston_housing.load_data() model = Sequential() model.add(Dense(1, input_shape=(x_train.shape[1], ), activation='linear')) model.compile(optimizer='adam', loss='mse', metrics=['mse', 'mae']) learner = ktrain.get_learner(model, train_data=(x_train, y_train), val_data=(x_test, y_test)) learner.lr_find() hist = learner.fit(0.05, 8, cycle_len=1, cycle_mult=2) learner.view_top_losses(n=5) learner.validate() return hist
def load_data(): """Collects and, if necessary, cleans datasets used for training the model, testing the model, and making predictions. The training and testing data set need to provide the independent features (x) and the result (y) for each example in the data set. The prediction data set only needs to provide the independent features to make predictions for. Returns: tuple -- The three data sets ((training_x, training_y), (testing_x, testing_y), prediction_x) """ train, test = boston_housing.load_data() predict = list(zip(*choices(list(zip(*test)), k=10))) return (train, test, predict)
def build_model(): (train_data, train_targets), (test_data, test_targets) = boston_housing.load_data() ''' mean = train_data.mean(axis=0) train_data -= mean std = train_data.std(axis=0) train_data /= std test_data -= mean test_data /= std ''' sc = MinMaxScaler() train_data = sc.fit_transform(train_data) test_data = sc.transform(test_data) x_val = train_data[:50] partial_x_train = train_data[50:] y_val = train_targets[:50] partial_y_train = train_targets[50:] model = models.Sequential() model.add(layers.Dense(128, activation='relu', input_shape=(13, ))) model.add(layers.Dropout(0.3)) model.add(layers.Dense(128, activation='relu')) model.add(layers.Dropout(0.3)) model.add(layers.Dense(1)) model.compile(optimizer='rmsprop', loss='mae', metrics=['mae']) history = model.fit(partial_x_train, partial_y_train, epochs=20, batch_size=12, validation_data=(x_val, y_val)) ''' results = model.evaluate(test_data, test_targets) print(model.predict(test_data)) print(results) ''' predicted = model.predict(test_data) base = np.asarray(range(len(predicted))) plt.plot(base, predicted, label="Predicted") plt.plot(base, test_targets, label="Real") plt.legend() plt.show() '''
def import_boston_housing(): (x_train, y_train), (x_test, y_test) = boston_housing.load_data() x_train = np.array(x_train) y_train = np.array(y_train) x_test = np.array(x_test) y_test = np.array(y_test) np.save(boston_housing_constants.boston_housing_np_save_dir + 'x_train', x_train) np.save(boston_housing_constants.boston_housing_np_save_dir + 'y_train', y_train) np.save(boston_housing_constants.boston_housing_np_save_dir + 'x_test', x_test) np.save(boston_housing_constants.boston_housing_np_save_dir + 'y_test', y_test) return
def main(): global train_data, train_targets, test_data, test_targets (train_data, train_targets), (test_data, test_targets) = boston_housing.load_data() # Normalizing the data mean = train_data.mean(axis=0) train_data -= mean std = train_data.std(axis=0) train_data /= std test_data -= mean test_data /= std k_fold_validation()
def task3(): data = Data.from_keras(boston_housing.load_data()) data.apply_standard_scaler() data.print_info() nn = NeuralNetwork(data) nn.grid_search({"layers": [(80, 80), (40, 40, 40, 40)]}) nn.train(50) nn.print_info() nn.grid_search({ "layers": [(80, 80), (0, 0, 0, 0)], "dropout": [0.5], }) nn.train(50) nn.print_info()
def test_regression(): (x_train, y_train), (x_test, y_test) = boston_housing.load_data() supervision_metric = 'mae' ivis_boston = Ivis(k=15, batch_size=16, epochs=5, supervision_metric=supervision_metric) ivis_boston.fit(x_train, y_train) embeddings = ivis_boston.transform(x_train) y_pred = ivis_boston.score_samples(x_train) assert ivis_boston.model_.loss['supervised'] == 'mae' assert ivis_boston.model_.layers[-1].activation.__name__ == 'linear' assert ivis_boston.model_.layers[-1].output_shape[-1] == 1
def main(): """Runs the program.""" (train_data, train_targets), (test_data, test_targets) = \ boston_housing.load_data() print(train_data.shape) (train_data, test_data) = normalize(train_data, test_data) input_shape = train_data.shape[1:] k = 4 num_val_examples = len(train_data) // k num_epochs = 500 all_mae_histories = [] start = time.time() for i in range(k): print('Processing fold {0}.'.format(i)) val_data = train_data[i * num_val_examples:(i + 1) * num_val_examples] val_targets = train_targets[i * num_val_examples:(i + 1) * num_val_examples] partial_train_data = np.concatenate([ train_data[:i * num_val_examples], train_data[(i + 1) * num_val_examples:] ], axis=0) partial_train_targets = np.concatenate([ train_targets[:i * num_val_examples], train_targets[(i + 1) * num_val_examples:] ], axis=0) model = get_model(input_shape) history = model.fit(partial_train_data, partial_train_targets, validation_data=(val_data, val_targets), epochs=num_epochs, batch_size=1, verbose=0) mae_history = history.history['val_mean_absolute_error'] all_mae_histories.append(mae_history) stop = time.time() print('Time: {0}'.format(stop - start)) average_mae_history = [ np.mean([x[i] for x in all_mae_histories]) for i in range(num_epochs) ] plot_history(average_mae_history) print('Training final model.') model = get_model(input_shape) model.fit(train_data, train_targets, epochs=80, batch_size=16, verbose=0) test_mse_score, test_mae_score = model.evaluate(test_data, test_targets) print('Test score: {0}'.format(test_mae_score))
def main(): model = Sequential() relu = "relu" softmax = "softmax" debug_output = False model.add(Dense(units=32, activation=relu, input_dim=13)) model.add(Dense(units=1, activation=relu)) # model.add(Dense(units=10, activation=softmax)) # check the layers.. l1 = model.layers[0] l2 = model.layers[1] # 'configure learning process': # multi-class classification problem (still true for rmsprop/mse)?? model.compile(optimizer='rmsprop', loss='mean_squared_error', metrics=['accuracy']) # model.compile(optimizer='categorical_crossentropy', # loss='sgd', # metrics=['accuracy']) #load example data (x_train, y_train), (x_test, y_test) = boston_housing.load_data() data = x_train labels = y_train if debug_output: print(data) print(labels) #train network model.fit(x_train, y_train, epochs=20, batch_size=5, verbose=0) # optionally, train on batch: # model.train_on_batch(x_batch, y_batch) #convenience method for saving model structure/data: path = "json_model.json" with open(path, 'w') as outfile: print(model.to_json(), file=outfile) loss_and_metrics = model.evaluate(x_test, y_test, batch_size=5)
# https://www.tensorflow.org/guide/low_level_intro # # only needed for python 2.7 # from __future__ import absolute_import # from __future__ import division # from __future__ import print_function import numpy as np from numpy import array from numpy import float32 from keras.datasets import boston_housing (x_train, y_train), (x_test, y_test) = boston_housing.load_data() print (x_train.shape) print (x_train.dtype) print (y_train.shape) print (y_train.dtype) np.reshape(y_train, (404, -1)) print(y_train.shape)
model.compile(optimizer='rmsprop', loss='mse', metrics=['mae']) return model def smooth_curve(points, factor=0.9): smoothed_points = [] for point in points: if smoothed_points: previous = smoothed_points[-1] smoothed_points.append(previous * factor + point*(1-factor)) else: smoothed_points.append(point) return smoothed_points if __name__ == '__main__': from keras.datasets import boston_housing (train_data, train_targets), (test_data, test_targets) = boston_housing.load_data() print(train_data.shape) print(test_data.shape) mean = train_data.mean(axis=0) std = train_data.std(axis=0) train_data = (train_data-mean)/std test_data = (test_data-mean)/std k = 4 # K-fold validataion num_val_samples = len(train_data) // k num_epochs = 500 all_mae_history = [] for i in range(k): print('processing fold #', i) val_data = train_data[i*num_val_samples: (i+1)*num_val_samples] val_targets = train_targets[i*num_val_samples: (i+1)*num_val_samples]
from keras.datasets import boston_housing (train_data, train_targets), (test_data, test_targets) = boston_housing.load_data() # print(train_data.shape) # print(train_data) # print(train_targets.shape) # print(train_targets) # print(test_data.shape) # print(test_targets.shape) # print() mean = train_data.mean(axis=0) train_data -= mean std = train_data.std(axis=0) train_data /= std test_data -= mean test_data /= std from keras import models from keras import layers def build_model(): model = models.Sequential() model.add( layers.Dense( 64, activation='relu', input_shape=(train_data.shape[1], ))) model.add(layers.Dense(64, activation='relu')) model.add(layers.Dense(1))
def section3pt6(): print('\n##############################') print('\nstarting: section3pt6()') (train_data, train_targets), (test_data, test_targets) = boston_housing.load_data() print('\ntrain_data.shape') print( train_data.shape ) print('\ntrain_targets.shape') print( train_targets.shape ) print('\ntest_data.shape') print( test_data.shape ) print('\ntest_targets.shape') print( test_targets.shape ) print('\ntrain_targets') print( train_targets ) ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ### # normalize data mean = train_data.mean(axis=0) train_data -= mean std = train_data.std(axis=0) train_data /= std test_data -= mean test_data /= std ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ### ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ### print('\n### starting: fitting model with 80 epochs ...') model = build_model(train_data = train_data) print('\nmodel.summary()') print( model.summary() ) model.fit( train_data, train_targets, epochs = 80, batch_size = 16, verbose = 2 ) test_mse_score, test_mae_score = model.evaluate(test_data, test_targets) print('\ntest_mse_score:',test_mse_score) print('\ntest_mae_score:',test_mae_score) print('\n### finished: fitting model with 80 epochs') print('\n') ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ### ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ### # return( None ) ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ### ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ### ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ### print('\n### starting: training with k-fold cross-validation ...') k = 4 # number of fold (in k-fold cross-validation) num_val_samples = len(train_data) // k num_epochs = 500 all_mae_histories = [] for i in range(k): print('processing fold #', i) val_data = train_data[ i * num_val_samples: (i + 1) * num_val_samples] val_targets = train_targets[i * num_val_samples: (i + 1) * num_val_samples] partial_train_data = np.concatenate( [train_data[:i * num_val_samples], train_data[(i + 1) * num_val_samples:]], axis = 0 ) partial_train_targets = np.concatenate( [train_targets[:i * num_val_samples], train_targets[(i + 1) * num_val_samples:]], axis = 0 ) model = build_model(train_data = partial_train_data) history = model.fit( partial_train_data, partial_train_targets, validation_data = (val_data, val_targets), epochs = num_epochs, batch_size = 1, verbose = 2 ) mae_history = history.history['val_mean_absolute_error'] all_mae_histories.append(mae_history) average_mae_history = [ np.mean([x[i] for x in all_mae_histories]) for i in range(num_epochs) ] print('\n### finished: training with k-fold cross-validation') print('\n') ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ### outputFILE = 'plot-housing-validation.png' plt.plot(range(1, len(average_mae_history) + 1), average_mae_history) plt.title('Validation MAE by epoch') plt.xlabel('Epochs') plt.ylabel('Validation MAE') plt.legend() plt.savefig(fname = outputFILE, dpi = 600, bbox_inches = 'tight', pad_inches = 0.2) plt.clf() ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ### outputFILE = 'plot-housing-validation-exclude-first-ten.png' smooth_mae_history = smooth_curve(average_mae_history[10:]) plt.plot(range(1, len(smooth_mae_history) + 1), smooth_mae_history) plt.title('Validation MAE by epoch, excluding first 10 data points') plt.xlabel('Epochs') plt.ylabel('Validation MAE') plt.savefig(fname = outputFILE, dpi = 600, bbox_inches = 'tight', pad_inches = 0.2) plt.clf() ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ### print('\nexitng: section3pt6()') print('\n##############################') return( None )
# Predicting house prices: a regression example from keras.datasets import boston_housing from utils import normalize_data from keras import models, layers, optimizers, losses, metrics # loading the Boston housing dataset (train_data, train_labels), (test_data, test_labels) = boston_housing.load_data() # dataset info print(train_data.shape) print(test_data.shape) # preparing the data # Normalizing the data train_data = normalize_data(train_data) test_data = normalize_data(test_data) # build your network def build_model(): model = models.Sequential() model.add(layers.Dense(64, activation='relu', input_shape=(train_data.shape[1],))) model.add(layers.Dense(64, activation='relu')) model.add(layers.Dense(1)) model.compile(optimizer=optimizers.Adam(lr=0.001), loss=losses.mse, metrics=[metrics.mae]) return model network = build_model() # train network.fit(train_data, train_labels, epochs=80) loss, acc = network.evaluate(test_data, test_labels) print(loss, acc)