def image_regression(self, output_dim: int = None, **kwargs) -> ak.ImageRegressor: """Image Regression. Args: output_dim (int, optional): Number of output dimensions. Defaults to None. Returns: ak.ImageRegressor: AutoKERAS image regression class. """ return ak.ImageRegressor( output_dim=output_dim, loss=self.loss, metrics=self.metrics, project_name=self.project_name, max_trials=self.max_trials, directory=self.directory, objective=self.objective, tuner=self.tuner, overwrite=self.overwrite, seed=self.seed, max_model_size=self.max_model_size, **kwargs, )
def test_img_reg_fit_call_auto_model_fit(fit, tmp_path): auto_model = ak.ImageRegressor(directory=tmp_path, seed=utils.SEED) auto_model.fit(x=utils.generate_data(num_instances=100, shape=(32, 32, 3)), y=utils.generate_data(num_instances=100, shape=(1, ))) assert fit.is_called
def test_image_regressor(tmp_path): train_x = utils.generate_data(num_instances=320, shape=(32, 32, 3)) train_y = utils.generate_data(num_instances=320, shape=(1,)) clf = ak.ImageRegressor(directory=tmp_path, max_trials=2, seed=utils.SEED) clf.fit(train_x, train_y, epochs=1, validation_split=0.2) clf.export_model() assert clf.predict(train_x).shape == (len(train_x), 1)
def train_autokeras(l=None): if l is None: l = get_data() dirname = os.path.join(_mydir, 'autokeras') if not os.path.exists(dirname): os.makedirs(dirname) model = ak.ImageRegressor(path=dirname) # TODO fix this shape ... model.fit(np.atleast_3d(l.X_train.values), l.y_train.values.squeeze()) return attributedict_from_locals('model')
def build_model(self) -> ak.AutoModel: model = None if self.data_type == 'image': if self.task_type == 'regression': model = ak.ImageRegressor() elif self.task_type == 'classification': model = ak.ImageClassifier() elif self.data_type == 'text': if self.task_type == 'regression': model = ak.TextRegressor() elif self.task_type == 'classification': model = ak.TextRegressor() elif self.data_type == 'csv': if self.task_type == 'regression': model = ak.StructuredDataRegressor() elif self.task_type == 'classification': model = ak.StructuredDataClassifier() return model
def train_ak_regression(): print("Train MPII: AutoKeras Regression") x_train, y_train, x_test, y_test = loaddb.load_mpii(config.dbpath_mpii) reg = ak.ImageRegressor(overwrite=True, max_trials=config.max_trials, directory=config.outpath_mpii) reg.fit(x_train, y_train, validation_data=(x_test, y_test), epochs=config.epochs) print(reg.evaluate(x_test, y_test)) model = reg.export_model() print(type(model)) # model.save(config.out_path + "model_ak_imgRegr.h5") return 0
def test_image_regressor(_, tmp_dir): x_train = np.random.rand(100, 32, 32, 3) y_train = np.random.rand(100, 1) clf = ak.ImageRegressor(directory=tmp_dir, max_trials=2) clf.fit(x_train, y_train, epochs=2, validation_split=0.2)
import autokeras as ak # Load x, y dataset x, y = Utils.load_dataset('Data', task='regression') # Split x, y dataset # train-test split x_train, x_test, y_train, y_test = train_test_split(x, y, train_size=0.8, random_state=123) # train-val split x_train, x_val, y_train, y_val = train_test_split(x_train, y_train, train_size=0.8, random_state=456) # ImageRegressor model model = ak.ImageRegressor(metrics=['mae', 'mape'], max_trials=100, overwrite=True, seed=45) # Train model model.fit(x_train, y_train, epochs=200, validation_data=(x_val, y_val)) # Evaluate model score = model.evaluate(x_test, y_test) # Inference time - use magic command %timeit in IPython or IDE # %timeit model.predict_on_batch(x_test)
def test_image_regressor(tmp_dir): x_train = np.random.rand(100, 32, 32, 3) y_train = np.random.rand(100) clf = ak.ImageRegressor(directory=tmp_dir) clf.fit(x_train, y_train, epochs=2, trials=2) assert clf.predict(x_train).shape == (100,)
'data': "200k", } # ================== Import Data ================== DATA_PATH = get_git_root() + "data/simulated/" images = np.load(DATA_PATH + f"images_{config['data']}.npy") images = images.reshape(images.shape[0], 16, 16, 1) positions = np.load(DATA_PATH + "positions_200k.npy") labels = np.load(DATA_PATH + "labels_200k.npy") single_indices, double_indices, close_indices = event_indices(positions) train_idx, val_idx, non1, non2 = train_test_split( double_indices, double_indices, random_state=config['random_seed']) # log-scale the images if desireable config['scaling'] = "minmax" # set tf random seed with tf.device(get_tf_device(20)): reg = ak.ImageRegressor( overwrite=True, max_trials=100, ) # Feed the structured data regressor with training data. reg.fit( normalize_image_data(images[train_idx]), normalize_position_data(positions[train_idx]), validation_data=(normalize_image_data(images[val_idx]), normalize_position_data(positions[val_idx])), epochs=10, ) predicted_y = reg.predict(normalize_image_data(images[val_idx])) print(reg.evaluate(normalize_image_data(images[val_idx]), normalize_position_data(positions[val_idx])))
def train_keras(model_name, folder, nr_images_batch, nr_batch, nr_epoch, max_trials=10): """Training function for the regression Args: model_name (str): the name of the segmentation model folder (str): the path to the images nr_images_batch (int): number of images per batch nr_batch (int): number of batches nr_epoch (int): number of epochs max_trials (int, optional): number of trails for AutoKeras. Defaults to 10. Returns: mse: metric Mean Squared Error rmse: metric Root Mean Squared Error mae: metric Mean Absolut Error model: the trained model """ image_width = 192 image_height = 192 ratio = 1 channels = 3 logdir = "logs/scalars/" + datetime.now().strftime("%Y%m%d-%H%M%S") tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir) allfiles = [ f for f in os.listdir(folder) if os.path.isfile(os.path.join(folder, f)) ] for i in range(0, nr_batch): print("--- Batch {} --- ".format(str(i))) # Initialize the image regressor. reg = ak.ImageRegressor( project_name=model_name, # metrics=[tf.keras.metrics.MeanSquaredError(), # tf.keras.metrics.RootMeanSquaredError(), # tf.keras.metrics.MeanAbsoluteError()], overwrite=False, max_trials=max_trials) onlyfiles = allfiles[i * nr_images_batch:(i + 1) * nr_images_batch] print("select from to", i * nr_images_batch, (i + 1) * nr_images_batch) train_files = [] y_train = np.ndarray(len(onlyfiles)) for _file in onlyfiles: train_files.append(_file) y_train[i] = (np.float64(_file.split('_')[11])) print("Files in train_files: %d" % len(train_files)) image_width = int(image_width / ratio) image_height = int(image_height / ratio) dataset = np.ndarray(shape=(len(train_files), image_height, image_width, channels), dtype=np.float32) j = 0 for _file in train_files: img = load_img(folder + "/" + _file) # this is a PIL image #img.thumbnail((image_width, image_height)) # Convert to Numpy Array x = img_to_array(img) #x = x.reshape((3, 48, 48)) # Normalize #x = (x - 128.0) / 128.0 dataset[i] = x j += 1 if j % 1000 == 0: print("%d images to array" % j) print("All images to array!") #Splitting X_train = dataset #X_train, X_test, y_train, y_test = train_test_split(dataset, y_train, test_size=0.2, random_state=33) #X_test, X_val, y_test, y_val = train_test_split(X_test, y_test, test_size=0.5, random_state=33) #print("Train set size: {0}, Val set size: {1}, Test set size: {2}".format(len(X_train), len(X_val), len(X_test))) #print(y_train[0]) # Feed the image regressor with training data. if i + 1 == nr_batch: print("Last run, eval the model") y_hat = reg.predict(dataset) m = tf.keras.metrics.MeanSquaredError(name="mean_squared_error", dtype=None) m.update_state(y_hat, y_train) mse = m.result().numpy() m = tf.keras.metrics.RootMeanSquaredError( name="root_mean_squared_error", dtype=None) m.update_state(y_hat, y_train) rmse = m.result().numpy() m = tf.keras.metrics.MeanAbsoluteError(name="mean_absolute_error", dtype=None) m.update_state(y_hat, y_train) mae = m.result().numpy() return reg, mse, rmse, mae else: reg.fit(X_train, y_train, validation_split=0.2, batch_size=25, epochs=nr_epoch)
train_dir='/data/training.csv' test_dir='/data/test.csv' train=pd.read_csv(train_dir) test=pd.read_csv(test_dir) train=train.dropna() train=train.reset_index(drop=True) X_train=[] Y_train=[] for img in train['Image']: X_train.append(np.asarray(img.split(),dtype=float).reshape(96,96,1)) X_train=np.reshape(X_train,(-1,96,96,1)) X_train = np.asarray(X_train).astype('float32') for i in range(len((train))): Y_train.append(np.asarray(train.iloc[i][0:30].to_numpy())) Y_train = np.asarray(Y_train).astype('float32') ## Data training reg = ak.ImageRegressor(max_trials=MAX_TRIALS) reg.fit(X_train, Y_train, validation_split=0.15, epochs=EPOCHS) # Export trained model to externally attached pvc my_model = reg.export_model() my_model.save('/data/model_autokeras', save_format="tf")
if __name__ == '__main__': ad_size = 1 # Load and select data x_train, x_test, y_train, y_test = LoadAndSelectData(ad_size) x_train = x_train.reshape(int(x_train.size / ad_size/7), ad_size, 7, 1) x_test = x_test.reshape(int(x_test.size / ad_size/7), ad_size, 7, 1) print((x_train.shape, y_train.shape)) print((x_test.shape, y_test.shape)) x_train = x_train.astype('int8') y_train = y_train.astype('int8') x_test = x_train.astype('int8') y_test = y_train.astype('int8') #print('Training data shape:%d' % (min(x_train.flatten()))) x_train = (x_train / 128).astype('float32') x_test = (x_test / 128).astype('float32') y_train = ((y_train)/128).astype('float32') y_test = ((y_test) / 128).astype('float32') # Initialize the classifier. reg = ak.ImageRegressor(max_trials=20) # x is the path to the csv file. y is the column name of the column to predict. reg.fit(x=x_train, y=y_train, epochs=30) # Evaluate the accuracy of the found model. print(reg.evaluate(x=x_test, y=y_test)) model = reg.export_model() model.save("autokeras")
import numpy as np import tensorflow as tf from tensorflow.keras.layers import Conv2D, Dropout import autokeras as ak from tensorflow.keras.datasets import mnist (x_train, y_train), (x_test, y_test) = mnist.load_data() print(x_train.shape, y_train.shape) print(y_train[:3]) model = ak.ImageRegressor( overwrite=True, max_trials=3, loss='mae', metrics=['mse'], ) #model.summary() #안먹힘 from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint from tensorflow.keras.callbacks import ReduceLROnPlateau es = EarlyStopping(monitor='val_loss', mode='min', patience=6) lr = ReduceLROnPlateau(monitor='val_loss', mode='auto', patience=3, factor=0.2, verbose=2) ck = ModelCheckpoint('C:/data/MC/', save_weight_only=True, save_best_only=True, monitor='val_loss',
def test_image_regressor(tmp_dir): train_x = common.generate_data(num_instances=100, shape=(32, 32, 3)) train_y = common.generate_data(num_instances=100, shape=(1, )) clf = ak.ImageRegressor(directory=tmp_dir, max_trials=2, seed=common.SEED) clf.fit(train_x, train_y, epochs=1, validation_split=0.2) assert clf.predict(train_x).shape == (len(train_x), 1)
ages = train_set["age"].astype("int").to_numpy() return image_inputs, ages train_set = df[df["full_path"] < "02"].sample(200) train_imgs, train_ages = df2numpy(train_set) test_set = df[df["full_path"] < "02"].sample(100) test_imgs, test_ages = df2numpy(test_set) """ ### **Training using AutoKeras** """ # Initialize the image regressor reg = ak.ImageRegressor(max_trials=15) # AutoKeras tries 15 different models. # Find the best model for the given training data reg.fit(train_imgs, train_ages) # Predict with the chosen model: # predict_y = reg.predict(test_images) # Uncomment if required # Evaluate the chosen model with testing data print(reg.evaluate(test_images, test_ages)) """ ### **Validation Data** By default, AutoKeras use the last 20% of training data as validation data. As shown in the example below, you can use validation_split to specify the percentage. """
model.save(fr'mymodel1.h5') !pip install folium==0.2.1 !pip install imgaug==0.2.7 #!pip install autokeras !pip uninstall pytorch torchvision -y !pip3 install https://download.pytorch.org/whl/cpu/torch-1.0.1-cp36-cp36m-win_amd64.whl !pip3 install torchvision import autokeras as ak model_ak = ak.ImageRegressor(verbose = True) model_ak.fit(Xgen,Ygen, time_limit=60*60) score = model_ak.evaluate(X_val, y_val) print(score) ypred = model_ak.predict(X) plt.plot(y,'g', ypred,'r') plt.show() model_ak.export_autokeras_model("autoKeras.pkl") from autokeras.utils import pickle_from_file model = pickle_from_file('autoKeras.pkl')