def data(): nb_classes = 10 # the data, shuffled and split between train and test sets (X_train, y_train), (X_test, y_test) = cifar10.load_data() print('X_train shape:', X_train.shape) print(X_train.shape[0], 'train samples') print(X_test.shape[0], 'test samples') # convert class vectors to binary class matrices Y_train = np_utils.to_categorical(y_train, nb_classes) Y_test = np_utils.to_categorical(y_test, nb_classes) X_train = X_train.astype('float32') X_test = X_test.astype('float32') X_train /= 255 X_test /= 255 # this will do preprocessing and realtime data augmentation datagen = ImageDataGenerator( featurewise_center=False, # set input mean to 0 over the dataset samplewise_center=False, # set each sample mean to 0 featurewise_std_normalization=False, # divide inputs by std of the dataset samplewise_std_normalization=False, # divide each input by its std zca_whitening=False, # apply ZCA whitening rotation_range=0, # randomly rotate images in the range (degrees, 0 to 180) width_shift_range=0.1, # randomly shift images horizontally (fraction of total width) height_shift_range=0.1, # randomly shift images vertically (fraction of total height) horizontal_flip=True, # randomly flip images vertical_flip=False) # randomly flip images # compute quantities required for featurewise normalization # (std, mean, and principal components if ZCA whitening is applied) datagen.fit(X_train) return datagen, X_train, Y_train, X_test, Y_test
def data_cifar10(): """ Preprocess CIFAR10 dataset :return: """ # These values are specific to CIFAR10 img_rows = 32 img_cols = 32 nb_classes = 10 # the data, shuffled and split between train and test sets (X_train, y_train), (X_test, y_test) = cifar10.load_data() if keras.backend.image_dim_ordering() == 'th': X_train = X_train.reshape(X_train.shape[0], 3, img_rows, img_cols) X_test = X_test.reshape(X_test.shape[0], 3, img_rows, img_cols) else: X_train = X_train.reshape(X_train.shape[0], img_rows, img_cols, 3) X_test = X_test.reshape(X_test.shape[0], img_rows, img_cols, 3) X_train = X_train.astype('float32') X_test = X_test.astype('float32') X_train /= 255 X_test /= 255 print('X_train shape:', X_train.shape) print(X_train.shape[0], 'train samples') print(X_test.shape[0], 'test samples') # convert class vectors to binary class matrices Y_train = np_utils.to_categorical(y_train, nb_classes) Y_test = np_utils.to_categorical(y_test, nb_classes) return X_train, Y_train, X_test, Y_test
def load_cifar_dataset(): from keras.datasets import cifar10 from keras.preprocessing.image import ImageDataGenerator num_classes = 10 data_augmentation = True num_predictions = 20 # The data, shuffled and split between train and test sets: (x_train, y_train), (x_test, y_test) = cifar10.load_data() # normalizing x_train = x_train.astype('float32') x_test = x_test.astype('float32') x_train /= 255 x_test /= 255 print('x_train shape:', x_train.shape) print(x_train.shape[0], 'train samples') print(x_test.shape[0], 'test samples') # Convert class vectors to binary class matrices. y_train = keras.utils.to_categorical(y_train, num_classes) y_test = keras.utils.to_categorical(y_test, num_classes) return x_train, y_train, x_test, y_test
def main(): # load data #mndata = MNIST('../data') #train_data=mndata.load_training() #test_data=mndata.load_testing() (X_train, y_train), (X_test, y_test) = cifar10.load_data() # parse aguments parser = argparse.ArgumentParser(description='train simple resnet') parser.add_argument('-e', metavar='epochs', dest="epochs",type=int, help='number of training epochs') parser.add_argument('-b', metavar='batch_size', dest="batch_size",type=int, help='batch_size to train with') parser.add_argument('-s', metavar='samples', dest="samples",type=int, help='number of training samples to use') parser.add_argument('-d', metavar='depth', dest="depth",type=int, help='number of reblocks to use') parser.add_argument('-p', metavar="survival_p", dest="survival_p", type=float, help='set this to use stochastic resnet') parser.add_argument('-f', metavar="filter_increase", dest="filt_inc", nargs='+', help='specify at which resblocks the filters should double') parser.set_defaults(epochs=100,samples=0,batch_size=20,depth=17,survival_p=.5,filt_inc=[3,7,13]) args = parser.parse_args() epochs=args.epochs samples = len(train_data[1]) if args.samples == 0 else args.samples batch_size=args.batch_size depth=args.depth samples_test = len(test_data[1]) if args.samples == 0 else args.samples pl=args.survival_p filt_inc = args.filt_inc X_train = np.array(X_train[:samples]) y_train = np.array(y_train[:samples]) X_test = np.array(X_test[:samples_test]) y_test = np.array(y_test[:samples_test]) z = np.array([binomial(1,1-(d/depth)*(1-pl)) for d in range(1,depth)]) #.reshape(1,16) resnet = get_resnet((3,32,32), depth, filt_inc,z) sgd =SGD(lr=0.001, decay=1e-4,momentum=0.9) resnet.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy']) labels = to_categorical(y_train, 10) #sample_z = SurvivalProb(depth,pl) #Z = np.array([z for e in range(batch_size)]) resnet.fit([X_train],labels,nb_epoch=epochs,batch_size=batch_size) labels_test = to_categorical(y_test, 10) #resnet.z = np.ones(depth) score = resnet.evaluate(X_test, labels_test, batch_size=batch_size) print(score)
def main(_): if FLAGS.dataset == 'cifar10': (X_train, y_train), (_, _) = cifar10.load_data() X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.2, random_state=0) else: with open('data/train.p', mode='rb') as f: train = pickle.load(f) X_train, X_val, y_train, y_val = train_test_split(train['features'], train['labels'], test_size=0.33, random_state=0) train_output_file = "{}_{}_{}.p".format(FLAGS.network, FLAGS.dataset, 'bottleneck_features_train') validation_output_file = "{}_{}_{}.p".format(FLAGS.network, FLAGS.dataset, 'bottleneck_features_validation') print("Resizing to", (w, h, ch)) print("Saving to ...") print(train_output_file) print(validation_output_file) with tf.Session() as sess: K.set_session(sess) K.set_learning_phase(1) model = create_model() print('Bottleneck training') train_gen = gen(sess, X_train, y_train, batch_size) bottleneck_features_train = model.predict_generator(train_gen(), X_train.shape[0]) data = {'features': bottleneck_features_train, 'labels': y_train} pickle.dump(data, open(train_output_file, 'wb')) print('Bottleneck validation') val_gen = gen(sess, X_val, y_val, batch_size) bottleneck_features_validation = model.predict_generator(val_gen(), X_val.shape[0]) data = {'features': bottleneck_features_validation, 'labels': y_val} pickle.dump(data, open(validation_output_file, 'wb'))
def build_data_cifar10(self): print("Loading data...") (self.Xtrain, _), (_, _) = cifar10.load_data() self.Xtrain = self.Xtrain[:501] self.extra = np.shape(self.Xtrain)[0] % self.batch_size if self.extra > 0: self.Xtrain = self.Xtrain[:-self.extra] Ytrain = self.Xtrain.copy() self.Xtrain[:,:,:,-self.margin:] = 0 RGB_Shapr = (np.shape(self.Xtrain)[0], np.shape(self.Xtrain)[2], np.shape(self.Xtrain)[3], 256) RGB_Shapr_train = (np.shape(self.Xtrain)[0], np.shape(self.Xtrain)[2]*np.shape(self.Xtrain)[3], 256) self.Rtrain = np.zeros(RGB_Shapr, dtype=self.Xtrain.dtype) self.Gtrain = np.zeros(RGB_Shapr, dtype=self.Xtrain.dtype) self.Btrain = np.zeros(RGB_Shapr, dtype=self.Xtrain.dtype) for s in range(np.shape(self.Xtrain)[0]): for j in range(3): for i in range(self.img_rows): for k in range(self.img_cols): if j == 0: self.Rtrain[s, i, k, Ytrain[s,j,i,k]] = 1 elif j == 1: self.Gtrain[s, i, k, Ytrain[s,j,i,k]] = 1 else: self.Btrain[s, i, k, Ytrain[s,j,i,k]] = 1 self.Rtrain = np.reshape(self.Rtrain,RGB_Shapr_train) self.Gtrain = np.reshape(self.Gtrain,RGB_Shapr_train) self.Btrain = np.reshape(self.Btrain,RGB_Shapr_train)
def load_cifar10(outputlayer='svm', theano_shared=True): ''' Loads the cifar dataset :type ds_rate: float :param ds_rate: downsample rate; should be larger than 1, if provided. :type theano_shared: boolean :param theano_shared: If true, the function returns the dataset as Theano shared variables. Otherwise, the function returns raw data. ''' (X_train, y_train), (X_test, y_test) = cifar10.load_data() train_set = X_train[0:45000,:,:].reshape((45000, 32*32*3)), y_train[0:45000,:].flatten() valid_set = X_train[45000:,:,:].reshape((5000, 32*32*3)), y_train[45000:,:].flatten() test_set = X_test.reshape((len(X_test), 32*32*3)), y_test.flatten() print('Loading cifar10 data with %s output layer' % outputlayer) if outputlayer=='svm': test_set_x, test_set_y = shared_svm(test_set) valid_set_x, valid_set_y = shared_svm(valid_set) train_set_x, train_set_y = shared_svm(train_set) if outputlayer=='Logistic': test_set_x, test_set_y = shared_dataset(test_set) valid_set_x, valid_set_y = shared_dataset(valid_set) train_set_x, train_set_y = shared_dataset(train_set) rval = [(train_set_x, train_set_y), (valid_set_x, valid_set_y), (test_set_x, test_set_y)] return rval
def train_on_cifar10(model): from keras.datasets import cifar10 from keras.utils import np_utils # settings batch_size = 32 nb_classes = 10 nb_epoch = 200 # the data, shuffled and split between train and test sets (X_train, y_train), (X_test, y_test) = cifar10.load_data() X_train = X_train.astype('float32') X_test = X_test.astype('float32') X_train /= 255. X_test /= 255. X_train -= np.mean(X_train, axis=0) X_test -= np.mean(X_test, axis=0) print('X_train shape:', X_train.shape) print(X_train.shape[0], 'train samples') print(X_test.shape[0], 'test samples') # convert class vectors to binary class matrices Y_train = np_utils.to_categorical(y_train, nb_classes) Y_test = np_utils.to_categorical(y_test, nb_classes) model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["accuracy"]) model.fit(X_train, Y_train, batch_size=batch_size, epochs=nb_epoch, validation_data=(X_test,Y_test)) score = model.evaluate(X_test, Y_test) print(score) return None
def __init__(self, **kwargs): super(CIFAR10, self).__init__(**kwargs) self.cls_names = cls_names (X_train, y_train), (X_test, y_test) = cifar10.load_data() y_train = y_train.reshape((y_train.shape[0])) y_test = y_test.reshape((y_test.shape[0])) if self.data_set == 'train': X = X_train y = y_train elif self.data_set == 'train-small': X = X_train[:1000] y = y_train[:1000] elif self.data_set == 'test': X = X_test y = y_test elif self.data_set == 'test-small': X = X_test[:1000] y = y_test[:1000] elif self.data_set == 'all': X = np.vstack((X_train, X_test)) y = np.vstack((y_train, y_test)) else: raise ValueError('MNIST Unsupported data_set: ', self.data_set) if X.shape[-1] == 3: X = X.transpose((0, 3, 1, 2)) # normalization if self.norm: X = X.astype(np.float32) / 255 X = self.init_layout_X(X) y = self.init_layout_y(y) self.X = X self.y = y
def data_mix(self): # randomly choose dataset dataset = random.choice(['mnist', 'cifar10', 'cifar100'])# n_labels = 10 if dataset == "mnist": data = mnist.load_data() if dataset == "cifar10": data = cifar10.load_data() if dataset == "cifar100": data = cifar100.load_data() n_labels = 100 # Choose dataset size. This affects regularization needed r = np.random.rand() # not using full dataset to make regularization more important and # speed up testing a little bit data_size = int( 2000 * (1-r) + 40000 * r ) # I do not use test data for validation, but last 10000 instances in dataset # so that trained models can be compared to results in literature (CX, CY), (CXt, CYt) = data if dataset == "mnist": CX = np.expand_dims(CX, axis=1) data = CX[:data_size], CY[:data_size], CX[-10000:], CY[-10000:]; return data, n_labels
def get_cifar10(): (X_train, y_train), (X_test, y_test) = cifar10.load_data() Y_train = np_utils.to_categorical(y_train, 10).astype("float32") Y_test = np_utils.to_categorical(y_test, 10).astype("float32") X_train = X_train.astype("float32") / 255 X_test = X_test.astype("float32") / 255 return (X_train, Y_train), (X_test, Y_test)
def construct_split_cifar10(task_labels, split='train'): """Split CIFAR10 dataset by labels. Args: task_labels: list of list of labels, one for each dataset split: whether to use train or testing data Returns: List of (X, y) tuples representing each dataset """ # Load CIFAR10 data and normalize nb_classes = 10 (X_train, y_train), (X_test, y_test) = cifar10.load_data() # X_train = X_train.reshape(-1, 3, 32, 32) # X_test = X_test.reshape(-1, 32**2) X_train = X_train.astype('float32') X_test = X_test.astype('float32') no = X_train.max() X_train /= no X_test /= no if split == 'train': X, y = X_train, y_train else: X, y = X_test, y_test return split_dataset_by_labels(X, y, task_labels, nb_classes)
def test(): from keras.datasets import mnist, cifar10 from keras.models import Sequential from keras.layers import Flatten, Dense, Activation, MaxPooling2D, Dropout, Convolution2D from keras.utils import np_utils (x_train, y_train), (x_test, y_test) = cifar10.load_data() x_train = x_train.astype('float32').reshape((len(x_train), 32, 32, 3)) / 255. x_test = x_test.astype('float32').reshape((len(x_test), 32, 32, 3)) / 255. y_train = np_utils.to_categorical(y_train) y_test = np_utils.to_categorical(y_test) rows, cols = x_train.shape[1:3] model = Sequential() model.add(SemiSupervizedConvolution2D(16, 3, 3, batch_input_shape=(16, rows, cols, 3))) model.add(Convolution2D(32, 3, 3, border_mode='same', dim_ordering='tf')) model.add(MaxPooling2D(pool_size=(2, 2), dim_ordering='tf')) model.add(Dropout(0.25)) model.add(SemiSupervizedConvolution2D(64, 3, 3)) model.add(Convolution2D(64, 3, 3, border_mode='same', dim_ordering='tf')) model.add(MaxPooling2D(pool_size=(2, 2), dim_ordering='tf')) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(512)) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(10)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') model.fit(x_train, y_train, batch_size=16, show_accuracy=True, validation_data=(x_test, y_test), nb_epoch=20)
def train(self): # load data (x_train, y_train), (x_test, y_test) = cifar10.load_data() y_train = keras.utils.to_categorical(y_train, self.num_classes) y_test = keras.utils.to_categorical(y_test, self.num_classes) x_train, x_test = self.color_preprocessing(x_train, x_test) # build network model = self.build_model() model.summary() # Save the best model during each training checkpoint checkpoint = ModelCheckpoint(self.model_filename, monitor='val_loss', verbose=0, save_best_only= True, mode='auto') plot_callback = PlotLearning() tb_cb = TensorBoard(log_dir=self.log_filepath, histogram_freq=0) cbks = [checkpoint, plot_callback, tb_cb] # set data augmentation print('Using real-time data augmentation.') datagen = ImageDataGenerator(horizontal_flip=True,width_shift_range=0.125,height_shift_range=0.125,fill_mode='constant',cval=0.) datagen.fit(x_train) # start training model.fit_generator(datagen.flow(x_train, y_train,batch_size=self.batch_size),steps_per_epoch=self.iterations,epochs=self.epochs,callbacks=cbks,validation_data=(x_test, y_test)) model.save(self.model_filename) self._model = model
def load_cifar10_data(img_rows, img_cols): # Load cifar10 training and validation sets (X_train, Y_train), (X_valid, Y_valid) = cifar10.load_data() # Resize training images X_train = X_train[:5000] Y_train = Y_train[:5000] X_valid = X_train[:5000] Y_valid = Y_valid[:5000] X_train = np.array([cv2.resize(img, (img_rows, img_cols)) for img in X_train]) X_valid = np.array([cv2.resize(img, (img_rows, img_cols)) for img in X_valid]) # Transform targets to keras compatible format Y_train = np_utils.to_categorical(Y_train, num_classes) Y_valid = np_utils.to_categorical(Y_valid, num_classes) X_train = X_train.astype('float32') X_valid = X_valid.astype('float32') # preprocess data X_train = X_train / 255.0 X_valid = X_valid / 255.0 return X_train, Y_train, X_valid, Y_valid
def cifar10(*args, **kwargs): dataset = cx.Dataset() from keras.datasets import cifar10 (x_train, y_train), (x_test, y_test) = cifar10.load_data() inputs = np.concatenate((x_train, x_test)) x_train, x_test = None, None inputs = inputs.astype('float32') inputs /= 255 labels = np.concatenate((y_train, y_test)) y_train, y_test = None, None targets = to_categorical(labels, 10) labels = np.array([str(label[0]) for label in labels], dtype=str) dataset.name = "CIFAR-10" dataset.description = """ Original source: https://www.cs.toronto.edu/~kriz/cifar.html The CIFAR-10 dataset consists of 60000 32x32 colour images in 10 classes, with 6000 images per class. The classes are completely mutually exclusive. There is no overlap between automobiles and trucks. "Automobile" includes sedans, SUVs, things of that sort. "Truck" includes only big trucks. Neither includes pickup trucks. """ dataset.load_direct([inputs], [targets], [labels]) return dataset
def get_data(self): from keras.datasets import cifar10 (X_train, y_train), (X_test, y_test) = cifar10.load_data() if self.verbose: print('X_train shape:', X_train.shape) print(X_train.shape[0], 'train samples') print(X_test.shape[0], 'test samples') # convert class vectors to binary class matrices from keras.utils import np_utils Y_train = np_utils.to_categorical(y_train, nb_classes) Y_test = np_utils.to_categorical(y_test, nb_classes) X_train = X_train.astype('float32') X_test = X_test.astype('float32') X_train /= 255 X_test /= 255 img_mean = X_train.mean(axis=0)[np.newaxis,:,:,:] N = X_train.shape[0] perms = np.random.permutation(N) self.X_train = X_train[perms,:] self.Y_train = Y_train[perms,:] self.X_test = X_test self.Y_test = Y_test self.rawdata=[self.X_train, self.Y_train, self.X_test, self.Y_test, img_mean]
def get_cifar10(): """Get cifar10 data.""" (X_train, y_train), (X_test, y_test) = cifar10.load_data() Y_train = np_utils.to_categorical(y_train, 10) Y_test = np_utils.to_categorical(y_test, 10) X_train = X_train.astype('float32') / 255 X_test = X_test.astype('float32') / 255 return X_train, X_test, Y_train, Y_test
def test_cifar(): # 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) = cifar10.load_data() (X_train, y_train), (X_test, y_test) = cifar100.load_data('fine') (X_train, y_train), (X_test, y_test) = cifar100.load_data('coarse')
def get_data(dataset='mnist'): """ images in [-0.5, 0.5] (instead of [0, 1]) which suits C&W attack and generally gives better performance :param dataset: :return: """ assert dataset in ['mnist', 'cifar', 'svhn'], \ "dataset parameter must be either 'mnist' 'cifar' or 'svhn'" if dataset == 'mnist': # the data, shuffled and split between train and test sets (X_train, y_train), (X_test, y_test) = mnist.load_data() # reshape to (n_samples, 28, 28, 1) X_train = X_train.reshape(-1, 28, 28, 1) X_test = X_test.reshape(-1, 28, 28, 1) elif dataset == 'cifar': # the data, shuffled and split between train and test sets (X_train, y_train), (X_test, y_test) = cifar10.load_data() else: if not os.path.isfile(os.path.join(PATH_DATA, "svhn_train.mat")): print('Downloading SVHN train set...') call( "curl -o ../data/svhn_train.mat " "http://ufldl.stanford.edu/housenumbers/train_32x32.mat", shell=True ) if not os.path.isfile(os.path.join(PATH_DATA, "svhn_test.mat")): print('Downloading SVHN test set...') call( "curl -o ../data/svhn_test.mat " "http://ufldl.stanford.edu/housenumbers/test_32x32.mat", shell=True ) train = sio.loadmat(os.path.join(PATH_DATA,'svhn_train.mat')) test = sio.loadmat(os.path.join(PATH_DATA, 'svhn_test.mat')) X_train = np.transpose(train['X'], axes=[3, 0, 1, 2]) X_test = np.transpose(test['X'], axes=[3, 0, 1, 2]) # reshape (n_samples, 1) to (n_samples,) and change 1-index # to 0-index y_train = np.reshape(train['y'], (-1,)) - 1 y_test = np.reshape(test['y'], (-1,)) - 1 # cast pixels to floats, normalize to [0, 1] range X_train = X_train.astype('float32') X_test = X_test.astype('float32') X_train = (X_train/255.0) - (1.0 - CLIP_MAX) X_test = (X_test/255.0) - (1.0 - CLIP_MAX) # one-hot-encode the labels Y_train = np_utils.to_categorical(y_train, 10) Y_test = np_utils.to_categorical(y_test, 10) print("X_train:", X_train.shape) print("Y_train:", Y_train.shape) print("X_test:", X_test.shape) print("Y_test", Y_test.shape) return X_train, Y_train, X_test, Y_test
def accuracy(self): (x_train, y_train), (x_test, y_test) = cifar10.load_data() y_train = keras.utils.to_categorical(y_train, self.num_classes) y_test = keras.utils.to_categorical(y_test, self.num_classes) # color preprocessing x_train, x_test = self.color_preprocessing(x_train, x_test) return self._model.evaluate(x_test, y_test, verbose=0)[1]
def load_data(): ''' load and normalize data from dataset files ''' (X, y), (X_test, y_test) = cifar10.load_data() n = X.shape[0] n1 = int(n * training_set_ratio) X_train=X[0:n1,:] y_train=y[0:n1] X_val=X[n1:n,:] y_val=y[n1:n] return X_train, y_train, X_val, y_val, X_test, y_test
def load_data(self): data_name = self.data_name if data_name == "MNIST": return mnist.load_data() elif data_name == "CIFAR10-GRAY": (X_train, y_train), (X_test, y_test) = cifar10.load_data() X_train_gray = rgb2gray(X_train) X_test_gray = rgb2gray(X_test) return (X_train_gray, y_train), (X_test_gray, y_test) else: raise ValueError("data_name of {} is not supported!".format(data_name))
def construct_transfer_cifar10_cifar100(nb_tasks=4, split='train'): """ Returns a two task dataset in which the first task is the full CIFAR10 dataset and the second task are 10 from CIFAR100 classes from the CIFAR100 dataset. params: nb_tasks The total number of tasks split Whether to return training or validation data returns: A list with two tuples containing the two data sets """ (X_train, y_train), (X_test, y_test) = cifar10.load_data() # X_train = X_train.reshape(-1, 3, 32, 32) # X_test = X_test.reshape(-1, 32**2) X_train = X_train.astype('float32') X_test = X_test.astype('float32') no = X_train.max() X_train /= no X_test /= no if split == 'train': X, y = X_train, y_train else: X, y = X_test, y_test nb_classes = nb_tasks*10 datasets = [(X,np_utils.to_categorical(y, nb_classes))] # Load CIFAR100 data and normalize (X_train, y_train), (X_test, y_test) = cifar100.load_data() X_train = X_train.astype('float32') X_test = X_test.astype('float32') m = np.max( (np.max(X_train), np.max(X_test) ) ) X_train /= m X_test /= m if split == 'train': X, y = X_train, y_train else: X, y = X_test, y_test # split dataset by labels task_labels = [ range(10*i,10*(i+1)) for i in range(1,nb_tasks) ] for labels in task_labels: idx = np.in1d(y+10, labels) data = X[idx], np_utils.to_categorical(y[idx]+10, nb_classes) datasets.append(data) all_task_labels = [range(10)] all_task_labels.extend(task_labels) return all_task_labels, datasets
def load_cifar_10(): from keras.datasets import cifar10 num_classes = 10 (x_train, y_train), (x_test, y_test) = cifar10.load_data() x_train = x_train.astype('float32') x_test = x_test.astype('float32') x_train /= 255.0 x_test /= 255.0 y_train = to_categorical(y_train, num_classes) y_test = to_categorical(y_test, num_classes) return (x_train,y_train),(x_test,y_test)
def load_data(): """ Load data using pre-configured dataset loader within keras. MNIST (http://yann.lecun.com/exdb/mnist/) - mnist.load_data() CIFAR10 (https://www.cs.toronto.edu/~kriz/cifar.html) - cifar10.load_data() CIFAR100 (https://www.cs.toronto.edu/~kriz/cifar.html) - cifar100.load_data() """ # The data, shuffled and split between train and test sets (X_data, train_labels), (y_data, test_labels) = cifar10.load_data() X_data = X_data.astype('float32')/255 y_data = y_data.astype('float32')/255 if GREYSCALE: train_data = rgb_to_greyscale(X_data) test_data = rgb_to_greyscale(y_data) else: train_data = X_data test_data = y_data # Number of classes in the used dataset nb_classes = 10 # input image dimensions img_rows, img_cols = 32, 32 # RGB images have 3 channels and greyscale images have 1 img_channels = test_data.shape[1] # Static creation of training and validating datasets validate_data_id = np.random.randint(train_data.shape[0], size=10000) validate_data = train_data[validate_data_id, :] validate_labels = train_labels[validate_data_id, :] train_data_id = np.random.randint(train_data.shape[0], size=40000) train_data = train_data[train_data_id, :] train_labels = train_labels[train_data_id, :] # create flat array of test labels for evaluation of the model validated_classes = list(chain.from_iterable(test_labels)) # convert class vectors to binary class matrices train_labels = np_utils.to_categorical(train_labels, nb_classes) validate_labels = np_utils.to_categorical(validate_labels, nb_classes) test_labels = np_utils.to_categorical(test_labels, nb_classes) dataset = Dataset(nb_classes, img_rows, img_cols, img_channels, validated_classes, train_data, train_labels, validate_data, validate_labels, test_data, test_labels) return dataset
def train(self, epochs, batch_size=128, sample_interval=50): # Load the dataset (X_train, y_train), (_, _) = cifar10.load_data() # Extract dogs and cats X_cats = X_train[(y_train == 3).flatten()] X_dogs = X_train[(y_train == 5).flatten()] X_train = np.vstack((X_cats, X_dogs)) # Rescale -1 to 1 X_train = X_train / 175.5 - 1. y_train = y_train.reshape(-1, 1) # Adversarial ground truths valid = np.ones((batch_size, 1)) fake = np.zeros((batch_size, 1)) for epoch in range(epochs): # --------------------- # Train Discriminator # --------------------- # Select a random batch of images idx = np.random.randint(0, X_train.shape[0], batch_size) imgs = X_train[idx] masked_imgs, missing_parts, _ = self.mask_randomly(imgs) # Generate a batch of new images gen_missing = self.generator.predict(masked_imgs) # Train the discriminator d_loss_real = self.discriminator.train_on_batch(missing_parts, valid) d_loss_fake = self.discriminator.train_on_batch(gen_missing, fake) d_loss = 0.5 * np.add(d_loss_real, d_loss_fake) # --------------------- # Train Generator # --------------------- g_loss = self.combined.train_on_batch(masked_imgs, [missing_parts, valid]) # Plot the progress print ("%d [D loss: %f, acc: %.2f%%] [G loss: %f, mse: %f]" % (epoch, d_loss[0], 100*d_loss[1], g_loss[0], g_loss[1])) # If at save interval => save generated image samples if epoch % sample_interval == 0: idx = np.random.randint(0, X_train.shape[0], 6) imgs = X_train[idx] self.sample_images(epoch, imgs)
def load_cifar10(): """ Loads the cifar10 dataset (60000 32x32 colur images) in 10 balanced classes. """ num_classes = 10 img_rows, img_cols = (32, 32) (x_train, y_train), (x_test, y_test) = cifar10.load_data() x_train, y_train = prepare_image_dataset(x_train, y_train, (img_rows, img_cols), num_classes, reshape=False) x_test, y_test = prepare_image_dataset(x_train, y_train, (img_rows, img_cols), num_classes, reshape=False) input_shape = (img_rows, img_cols, 3) return (x_train, y_train), (x_test, y_test), input_shape
def test_cifar(): # 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) = cifar10.load_data() assert len(x_train) == len(y_train) == 50000 assert len(x_test) == len(y_test) == 10000 (x_train, y_train), (x_test, y_test) = cifar100.load_data('fine') assert len(x_train) == len(y_train) == 50000 assert len(x_test) == len(y_test) == 10000 (x_train, y_train), (x_test, y_test) = cifar100.load_data('coarse') assert len(x_train) == len(y_train) == 50000 assert len(x_test) == len(y_test) == 10000
def __init__(self): # prepare trainigs data (X_train, y_train), (X_test, y_test) = cifar10.load_data() print('X_train shape:', X_train.shape) print(X_train.shape[0], 'train samples') print(X_test.shape[0], 'test samples') self.Y_train = np_utils.to_categorical(y_train, 10) self.Y_test = np_utils.to_categorical(y_test, 10) self.X_train = X_train.astype('float32') self.X_test = X_test.astype('float32') self.X_train /= 255 self.X_test /= 255
nbr_digits = 3 # paths save_path = os.path.join('../../../experiments', EXPERIMENT_ID) model_path = os.path.join('../../../experiments/', MODEL_EXP_ID) CNN_weights = os.path.join(model_path, 'best_weights.hdf5') CNN_arch = os.path.join(model_path, 'model.json') # create folder of experiments code, parameters and results createExpFolderandCodeList(save_path) # load model model = load_model(CNN_arch, CNN_weights) # load test set _, (data, y_true) = cifar10.load_data() y_true = np.squeeze(y_true) # select only zeros and ones data = data[(y_true == 0) + (y_true == 1)] y_true = y_true[(y_true == 0) + (y_true == 1)] # get meta data size_x = data[0].shape[-2] size_y = data[0].shape[-1] max_x = np.max(data) # add noise for i in range(len(data)): data[i] = add_noise(data[i])
import numpy as np from keras.models import Sequential from keras.layers import Dense from keras.layers import Dropout #Data 1. 数据 ''' Your data needs to be stored as NumPy arrays or as a list of NumPy arrays. Ideally, you split the data in training and test sets, for which you can also resort to the train_test_split module of sklearn.cross_validation. ''' ##Keras Data Sets 1.1 Keras数据集合 from keras.datasets import boston_housing, mnist, cifar10, imdb (x_train, y_train), (x_test, y_test) = mnist.load_data() (x_train2, y_train2), (x_test2, y_test2) = boston_housing.load_data() (x_train3, y_train3), (x_test3, y_test3) = cifar10.load_data() (x_train4, y_train4), (x_test4, y_test4) = imdb.load_data(num_words=20000) num_classes = 10 #Preprocessing 2. 预处理 ##Sequence Padding 2.1 序列填充 from keras.preprocessing import sequence x_train4 = sequence.pad_sequences(x_train4, maxlen=80) x_test4 = sequence.pad_sequences(x_test4, maxlen=80) ##One-Hot Encoding 2.2 独热编码 from keras.utils import to_categorical Y_train = to_categorical(y_train, num_classes) Y_test = to_categorical(y_test, num_classes) Y_train3 = to_categorical(y_train3, num_classes)
import matplotlib.pyplot as plt from keras.datasets import cifar10 from PIL import Image # 데이터 변수 선언 (x_train, y_train), (x_test, y_test) = cifar10.load_data() # Keras Dataset에서 다운받기 labels = [ 'airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck' ] # 이미지 출력 ------------------------------------- for i in range(40): img = Image.fromarray(x_train[i]) plt.subplot(5, 8, i + 1) plt.title(labels[y_train[i][0]]) plt.tick_params(bottom='off') plt.tick_params(left='off') plt.imshow(img) plt.show()
def main_color(): # load the CIFAR10 data (x_train, _), (x_test, y_test) = cifar10.load_data() #(x_train, _), (x_test, _) = mnist.load_data() """ for preprocessing, RGB to LAB for img in all of img DO CLAHE LAB to RGB """ x_train_prime = [] for _img in x_train: #_img = cv2.cvtColor(_img, cv2.COLOR_GRAY2RGB) #_img = cv2.resize(_img, (80, 80)) #_img = hist.preprocessing_hist(_img) x_train_prime.append(_img) x_train = np.array(x_train_prime) print(x_train.shape) x_test_prime = [] for _img in x_test: #_img = cv2.cvtColor(_img, cv2.COLOR_GRAY2RGB) #_img = cv2.resize(_img, (80, 80)) #_img = hist.preprocessing_hist(_img) x_test_prime.append(_img) x_test = np.array(x_test_prime) print(x_test.shape) """ written by wooramkang 2018.08.21 depending on CLAHE parameters, depending on dataset, you could use resizing and colorizing as well 08.22 filter grid size 2 * 2 4 * 4 8 * 8 16 * 16 """ img_rows = x_train.shape[1] img_cols = x_train.shape[2] channels = x_train.shape[3] imgs_dir = 'saved_images' save_dir = os.path.join(os.getcwd(), imgs_dir) if not os.path.isdir(save_dir): os.makedirs(save_dir) imgs = x_test[:100] print(y_test[:100]) i = 0 for _img in imgs: i = i+1 Image.fromarray(_img).save('saved_images/{0}_img_raw.png'.format(i)) #print raw img each image by image imgs = imgs.reshape((10, 10, img_rows, img_cols, channels)) imgs = np.vstack([np.hstack(i) for i in imgs]) Image.fromarray(imgs).save('saved_images/sumof_img_raw.png') x_train = x_train.astype('float32') / 255 x_test = x_test.astype('float32') / 255 x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, channels) x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, channels) input_shape = (img_rows, img_cols, 3) print(input_shape[1]) batch_size = 32 kernel_size = 3 latent_dim = 256 layer_filters = [64, 32, 16] inputs = Input(shape=input_shape, name='encoder_input') x = inputs for filters in layer_filters: x = Conv2D(filters=filters, kernel_size=kernel_size, strides=1, activation='relu', padding='same')(x) x = BatchNormalization()(x) x = Activation('elu')(x) for filters in layer_filters[::-1]: x = Conv2D(filters=filters, kernel_size=kernel_size, strides=1, activation='relu', padding='same')(x) x = BatchNormalization()(x) x = Activation('elu')(x) x = Dropout(rate=0.2)(x) x = Conv2D(filters=3, kernel_size=kernel_size, strides=1, activation='sigmoid', padding='same', name='finaloutput_AE' )(x) outputs = x#Conv2D(3, (3, 3), activation='relu', padding='same', name='finaloutput')(outputs) #decoder = Model(latent_inputs, outputs, name='decoder') #decoder.summary() #autoencoder = Model(inputs, decoder(encoder(inputs)), name='autoencoder') autoencoder = Model(inputs, x, name='autoencoder') autoencoder.summary() save_dir = os.path.join(os.getcwd(), 'saved_models') model_name = 'AE_model.{epoch:03d}.h5' if not os.path.isdir(save_dir): os.makedirs(save_dir) filepath = os.path.join(save_dir, model_name) lr_reducer = ReduceLROnPlateau(factor=np.sqrt(0.1), cooldown=0, patience=5, verbose=1, min_lr=0.5e-6) checkpoint = ModelCheckpoint(filepath=filepath, monitor='val_loss', verbose=1, save_best_only=True) autoencoder.compile(loss='mse', optimizer='adam') callbacks = [lr_reducer, checkpoint] # .fit(data for train, data for groundtruth, validtation set, epochs, batchsize, ...) autoencoder.fit(x_train, x_train, validation_data=(x_test, x_test), epochs=10, batch_size=batch_size, callbacks=callbacks) autoencoder.summary() x_decoded = autoencoder.predict(x_test) imgs = x_decoded[:100] print(imgs.shape) imgs = (imgs * 255).astype(np.uint8) i = 0 for _img in imgs: i = i + 1 Image.fromarray(_img).save('saved_images/{0}_img_gen.png'.format(i)) #print generated img each image by image imgs = imgs.reshape((10, 10, img_rows, img_cols, channels)) imgs = np.vstack([np.hstack(i) for i in imgs]) Image.fromarray(imgs).save('saved_images/sumof_img_gen.png')
server = tf.train.Server(cluster, job_name=FLAGS.job_name, task_index=FLAGS.task_index, config= config) def prepare_input_data(X_train, X_test): X_train = X_train.astype('float32') / 255.0 X_test = X_test.astype('float32') / 255.0 return X_train, X_test def prepare_output_data(y_train, y_test): y_train = np_utils.to_categorical(y_train) y_test = np_utils.to_categorical(y_test) return y_train, y_test (X_train, Y_train), (X_test, Y_test) = cifar10.load_data() x_train, x_test = prepare_input_data(X_train[:10000], X_test[:2000]) y_train, y_test = prepare_output_data(Y_train[:10000], Y_test[:2000]) # Network parameters n_classes = 10 image_size = 32 channel_size = 3 n_samples = x_train.shape[0] batch_size = 128 training_epochs = 5 num_iterations = n_samples//batch_size test_step = 100 sigma = 1e-3 lr= 1e-2 input_shape = (image_size,image_size, channel_size)
# Random Erasing of Image Data Augumentation import numpy as np import matplotlib.pyplot as plt from sklearn.utils import shuffle from sklearn.metrics import f1_score from sklearn.model_selection import train_test_split from keras.datasets import cifar10 (train_X, train_y), (test_X, test_y) = cifar10.load_data() # show images def show_images(dataset): for i in range(4): fig = dataset[i] plt.imshow(fig) plt.show() # Random Erasing def random_erasing(img): p = 0.5 s_l, s_h = 0.02, 0.4 r1, r2 = 0.3, 1.0 / 0.3 p1 = np.random.uniform(0, 1) if p1 < p: return img
def main(model_name, dataset, neural_function, batch_size=32, epochs=100, color=1, data_augmentation=True, is_neg=1): output_folder = "Output" save_models = "saved_models/" save_dir = os.path.join(output_folder, save_models) if dataset == "cifar10": (x_train_c, y_train), (x_test_c, y_test) = cifar10.load_data() num_classes = 10 elif dataset == "cifar100": (x_train_c, y_train), (x_test_c, y_test) = cifar100.load_data() num_classes = 100 print("Loaded {} dataset".format(dataset)) original_shape_train = x_train_c.shape original_shape_test = x_test_c.shape if color: x_train = x_train_c x_test = x_test_c else: x_train = np.zeros((original_shape_train[0], original_shape_train[1], original_shape_train[2], 1)) for k in range(original_shape_train[0]): x_train[k] = np.expand_dims(cv2.cvtColor(x_train_c[k], cv2.COLOR_BGR2GRAY), axis=3) x_test = np.zeros((original_shape_test[0], original_shape_test[1], original_shape_test[2], 1)) for k in range(original_shape_test[0]): x_test[k] = np.expand_dims(cv2.cvtColor(x_test_c[k], cv2.COLOR_BGR2GRAY), axis=3) print("Using {} images to train data".format( "color" if color else "greyscale")) print('x_train shape:', x_train.shape) print(x_train.shape[0], 'train samples') print(x_test.shape[0], 'test samples') # Convert class vectors to binary class matrices. y_train = keras.utils.to_categorical(y_train, num_classes) y_test = keras.utils.to_categorical(y_test, num_classes) input_shape = x_train.shape[1:] if neural_function == "linear": print("Using {} function for neurons".format(neural_function)) if model_name == "alexnet": original_lr = 0.0001 opt = RMSprop(lr=original_lr, decay=1e-6) dense_neu = 512 model = alexnet(input_shape, num_classes, dense_neurons=dense_neu) elif model_name == "resnet": depth = 20 model = resnet_v1(input_shape=input_shape, depth=depth, num_classes=num_classes) # opt = Adam(lr=lr_schedule(0)) original_lr = 0.0001 opt = RMSprop(lr=original_lr, decay=1e-6) elif neural_function == "quadratic": print("Using {} function for neurons".format(neural_function)) if model_name == "alexnet": original_lr = 0.0001 opt = RMSprop(lr=original_lr, decay=1e-6) model = qalexnet(input_shape, num_classes, activation='elu', is_neg=is_neg) elif model_name == "resnet": depth = 20 model = qresnet_v1(input_shape=input_shape, depth=depth, num_classes=num_classes, q=True, is_neg=is_neg) original_lr = 0.0001 opt = RMSprop(lr=original_lr, decay=1e-6) else: print("Undefined neural function \"{}\"".format(neural_function)) print("Compiling {} model with {} neural function to train on {}".format( model_name, neural_function, dataset)) model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy']) x_train = x_train.astype('float32') x_test = x_test.astype('float32') x_train /= 255 x_test /= 255 this_model_name = "{}_{}_{}_{}_{}".format( dataset, model_name, "negative" if is_neg else "positive", neural_function, "color" if color else "greyscale") print("Model name {}".format(this_model_name)) tensor_log_dir = 'logs/{}'.format(this_model_name) output_tensor_logs = os.path.join(output_folder, tensor_log_dir) print("Tensorflow log directory - {}".format(output_tensor_logs)) tensorboard = TensorBoard(log_dir=output_tensor_logs) if not data_augmentation: print('Not using data augmentation.') model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_data=(x_test, y_test), shuffle=True) else: print('Using real-time data augmentation.') # This will do preprocessing and realtime data augmentation: datagen = ImageDataGenerator( featurewise_center=False, # set input mean to 0 over the dataset samplewise_center=False, # set each sample mean to 0 featurewise_std_normalization= False, # divide inputs by std of the dataset samplewise_std_normalization=False, # divide each input by its std zca_whitening=False, # apply ZCA whitening zca_epsilon=1e-06, # epsilon for ZCA whitening rotation_range= 0, # randomly rotate images in the range (degrees, 0 to 180) # randomly shift images horizontally (fraction of total width) width_shift_range=0.1, # randomly shift images vertically (fraction of total height) height_shift_range=0.1, shear_range=0., # set range for random shear zoom_range=0., # set range for random zoom channel_shift_range=0., # set range for random channel shifts # set mode for filling points outside the input boundaries fill_mode='nearest', cval=0., # value used for fill_mode = "constant" horizontal_flip=True, # randomly flip images vertical_flip=False, # randomly flip images # set rescaling factor (applied before any other transformation) rescale=None, # set function that will be applied on each input preprocessing_function=None, # image data format, either "channels_first" or "channels_last" data_format=None, # fraction of images reserved for validation (strictly between 0 and 1) validation_split=0.0) datagen.fit(x_train) model.fit_generator(datagen.flow(x_train, y_train, batch_size=batch_size), epochs=epochs, validation_data=datagen.flow(x_test, y_test), workers=4, callbacks=[tensorboard]) if not os.path.isdir(save_dir): os.makedirs(save_dir) model_path = os.path.join(save_dir, this_model_name) model.save(model_path) print('Saved trained model at %s ' % model_path) scores = model.evaluate(x_test, y_test, verbose=1) print('Test loss:', scores[0]) print('Test accuracy:', scores[1]) results = [ datetime.datetime.now(), this_model_name, model.count_params(), scores[0], scores[1] ] testing_output_file = os.path.join(output_folder, "results.csv") with open(testing_output_file, 'a') as f: writer = csv.writer(f) writer.writerow(results)
def run_cifar10(batch_size, nb_epoch, depth, nb_dense_block, nb_filter, growth_rate, dropout_rate, learning_rate, weight_decay, logfile, plot_architecture): """ Run CIFAR10 experiments :param batch_size: int -- batch size :param nb_epoch: int -- number of training epochs :param depth: int -- network depth :param nb_dense_block: int -- number of dense blocks :param nb_filter: int -- initial number of conv filter :param growth_rate: int -- number of new filters added by conv layers :param dropout_rate: float -- dropout rate :param learning_rate: float -- learning rate :param weight_decay: float -- weight decay :param plot_architecture: bool -- whether to plot network architecture """ ################### # Data processing # ################### # the data, shuffled and split between train and test sets (X_train, y_train), (X_test, y_test) = cifar10.load_data() nb_classes = len(np.unique(y_train)) img_dim = X_train.shape[1:] if K.image_data_format() == "channels_first": n_channels = X_train.shape[1] else: n_channels = X_train.shape[-1] # convert class vectors to binary class matrices Y_train = np_utils.to_categorical(y_train, nb_classes) Y_test = np_utils.to_categorical(y_test, nb_classes) X_train = X_train.astype('float32') X_test = X_test.astype('float32') # Normalisation X = np.vstack((X_train, X_test)) # 2 cases depending on the image ordering if K.image_data_format() == "channels_first": for i in range(n_channels): mean = np.mean(X[:, i, :, :]) std = np.std(X[:, i, :, :]) X_train[:, i, :, :] = (X_train[:, i, :, :] - mean) / std X_test[:, i, :, :] = (X_test[:, i, :, :] - mean) / std elif K.image_data_format() == "channels_last": for i in range(n_channels): mean = np.mean(X[:, :, :, i]) std = np.std(X[:, :, :, i]) X_train[:, :, :, i] = (X_train[:, :, :, i] - mean) / std X_test[:, :, :, i] = (X_test[:, :, :, i] - mean) / std ################### # Construct model # ################### model = densenet.DenseNet(nb_classes, img_dim, depth, nb_dense_block, growth_rate, nb_filter, dropout_rate=dropout_rate, weight_decay=weight_decay) # Model output model.summary() # Build optimizer # opt = Adam(lr=learning_rate, beta_1=0.9, beta_2=0.999, epsilon=1e-08) opt = SGD(lr=learning_rate, momentum=0.9, nesterov=True) model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=["accuracy"]) if plot_architecture: from keras.utils.visualize_util import plot plot(model, to_file='./figures/densenet_archi.png', show_shapes=True) #################### # Network training # #################### print("Training") list_train_loss = [] list_test_loss = [] list_learning_rate = [] datagen = ImageDataGenerator() for e in range(nb_epoch): if e == int(0.5 * nb_epoch): K.set_value(model.optimizer.lr, np.float32(learning_rate / 10.)) if e == int(0.75 * nb_epoch): K.set_value(model.optimizer.lr, np.float32(learning_rate / 100.)) l_train_loss = [] start = time.time() model.fit_generator(datagen.flow(X_train, Y_train, batch_size), epochs=1) test_logloss, test_acc = model.evaluate(X_test, Y_test, verbose=1, batch_size=64) list_test_loss.append([test_logloss, test_acc]) list_learning_rate.append(float(K.get_value(model.optimizer.lr))) # to convert numpy array to json serializable print('Epoch %s/%s, Time: %s' % (e + 1, nb_epoch, time.time() - start)) d_log = {} d_log["batch_size"] = batch_size d_log["nb_epoch"] = nb_epoch d_log["optimizer"] = opt.get_config() # d_log["train_loss"] = list_train_loss d_log["test_loss"] = list_test_loss d_log["learning_rate"] = list_learning_rate json_file = os.path.join('./log', logfile) with open(json_file, 'w') as fp: json.dump(d_log, fp, indent=4, sort_keys=True)
import keras from keras.datasets import cifar10 from keras.layers import Dense, Activation, Flatten, Conv2D, MaxPooling2D from keras.models import Sequential from keras.utils import to_categorical, np_utils from PIL import Image from keras.optimizers import SGD import numpy as np import matplotlib.pyplot as plt import tensorflow as tf import os (train_X, train_Y), (test_X, test_Y) = cifar10.load_data() train_X = train_X.reshape(-1, 32, 32, 3) test_X = test_X.reshape(-1, 32, 32, 3) train_X = train_X.astype('float32') test_X = test_X.astype('float32') train_X = train_X / 255 test_X = test_X / 255 train_Y_one_hot = to_categorical(train_Y, 10) test_Y_one_hot = to_categorical(test_Y, 10) model = Sequential() model.add(Conv2D(64, (3, 3), activation='relu', input_shape=(32, 32, 3))) model.add(Conv2D(64, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten())
# epochs = int(save_file.split('/')[4].split('_')[1].split('.')[0]) starting_epoch = int(save_file.split('/')[4].split('.')[0].split('_')[-1]) data_augmentation = True num_classes = 10 # Subtracting pixel mean improves accuracy subtract_pixel_mean = True n = 3 # Model name, depth and version model_type = args.tc #'P100_resnet50_he_256_1' # Load the CIFAR10 data. (x_train, y_train), (x_test, y_test) = cifar10.load_data() # Normalize data. x_train = x_train.astype('float32') / 255 x_test = x_test.astype('float32') / 255 # If subtract pixel mean is enabled if subtract_pixel_mean: x_train_mean = np.mean(x_train, axis=0) x_train -= x_train_mean x_test -= x_train_mean print('x_train shape:', x_train.shape) print(x_train.shape[0], 'train samples') print(x_test.shape[0], 'test samples') print('y_train shape:', y_train.shape)
#Return the learning rate return float(alpha) # construct the argument parse and parse the arguments ap = argparse.ArgumentParser() ap.add_argument("-o", "--output", required=True, help="path to the output loss/accuracy plot") args = vars(ap.parse_args()) # load the training and testing data, then scale it into the # range [0, 1] print("[INFO] loading CIFAR-10 data...") ((trainX, trainY), (testX, testY)) = cifar10.load_data() trainX = trainX.astype("float") / 255.0 testX = testX.astype("float") / 255.0 # convert the labels from integers to vectors lb = LabelBinarizer() trainY = lb.fit_transform(trainY) testY = lb.transform(testY) # initialize the label names for the CIFAR-10 dataset labelNames = [ "airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck" ] #Define the set of callbacks to be passed to
def load_cifar10(): (X_train, y_train), (X_test, y_test) = cifar10.load_data() X_train = normalize_minus1_1(cast_to_floatx(X_train)) X_test = normalize_minus1_1(cast_to_floatx(X_test)) return (X_train, y_train), (X_test, y_test)
def CNN_conf(cfg, hist_save, epochs=1, test=False, gpu_no=0): verbose = 1 #CHRIS TODO set this to 0 batch_size = 100 num_classes = 10 epochs = 2000 #CHRIS increased from 1 to 5 to make results less random and noisy data_augmentation = False num_predictions = 20 logfile = 'mnist-cnn.log' savemodel = False # The data, shuffled and split between train and test sets: (x_train, y_train), (x_test, y_test) = cifar10.load_data() #mnist.load_data() #CHRIS reshape only needed for mnist #x_train = x_train.reshape(x_train.shape[0],x_train.shape[1],x_train.shape[2],1) #x_test = x_test.reshape(x_test.shape[0],x_test.shape[1],x_test.shape[2],1) cfg_df = pd.DataFrame(cfg, index=[0]) # Convert class vectors to binary class matrices. y_train = keras.utils.to_categorical(y_train.flatten(), num_classes) y_test = keras.utils.to_categorical(y_test.flatten(), num_classes) #print('skip steps:') #print([cfg['skint_0'],cfg['skint_1'],cfg['skint_2']],[cfg['skst_0'],cfg['skst_1'],cfg['skst_2']]) #(skip_ints,skip_ints_count) passed to Skip_manager constructor TODO get from cfg vector skip_manager = Skip_manager( [cfg['skint_0'], cfg['skint_1'], cfg['skint_2']], [cfg['skst_0'], cfg['skst_1'], cfg['skst_2']]) input1 = keras.layers.Input(shape=(x_train.shape[1], x_train.shape[2], x_train.shape[3])) layer = Dropout(cfg['dropout_0'], input_shape=x_train.shape[1:])(input1) layer = skip_manager.connect_skip(layer) #CHRIS removed following: #layer = Conv2D(cfg['filters_0'], (cfg['k_0'], cfg['k_0']), padding='same',kernel_regularizer=l2(cfg['l2']), bias_regularizer=l2(cfg['l2']))(layer) #layer = Activation(cfg['activation'])(layer)#kernel_initializer='random_uniform', #layer = skip_manager.connect_skip(layer) #stack 0 for i in range(cfg['stack_0']): layer = Conv2D(cfg['filters_0'], (cfg['k_0'], cfg['k_0']), padding='same', kernel_regularizer=l2(cfg['l2']), bias_regularizer=l2(cfg['l2']))(layer) layer = Activation(cfg['activation'])(layer) layer = skip_manager.connect_skip(layer) if (cfg['stack_0'] > 0): #maxpooling as cnn if (cfg['no_pooling']): layer = Conv2D(cfg['filters_1'], (cfg['k_1'], cfg['k_1']), strides=(cfg['s_0'], cfg['s_0']), padding='same', kernel_regularizer=l2(cfg['l2']), bias_regularizer=l2(cfg['l2']))(layer) else: layer = MaxPooling2D(pool_size=(cfg['k_1'], cfg['k_1']), strides=(cfg['s_0'], cfg['s_0']), padding='same')(layer) layer = Activation(cfg['activation'])(layer) layer = Dropout(cfg['dropout_1'])(layer) layer = skip_manager.connect_skip(layer) #stack 1 for i in range(cfg['stack_1']): layer = Conv2D(cfg['filters_2'], (cfg['k_2'], cfg['k_2']), padding='same', kernel_regularizer=l2(cfg['l2']), bias_regularizer=l2(cfg['l2']))(layer) layer = Activation(cfg['activation'])(layer) layer = skip_manager.connect_skip(layer) if (cfg['stack_1'] > 0): if (cfg['no_pooling']): layer = Conv2D(cfg['filters_3'], (cfg['k_3'], cfg['k_3']), strides=(cfg['s_1'], cfg['s_1']), padding='same', kernel_regularizer=l2(cfg['l2']), bias_regularizer=l2(cfg['l2']))(layer) else: layer = MaxPooling2D(pool_size=(cfg['k_3'], cfg['k_3']), strides=(cfg['s_1'], cfg['s_1']), padding='same')(layer) layer = Activation(cfg['activation'])(layer) layer = Dropout(cfg['dropout_2'])(layer) layer = skip_manager.connect_skip(layer) #stack 2 for i in range(cfg['stack_2']): layer = Conv2D(cfg['filters_4'], (cfg['k_4'], cfg['k_4']), padding='same', kernel_regularizer=l2(cfg['l2']), bias_regularizer=l2(cfg['l2']))(layer) layer = Activation(cfg['activation'])(layer) layer = skip_manager.connect_skip(layer) if (cfg['stack_2'] > 0): if (cfg['no_pooling']): layer = Conv2D(cfg['filters_5'], (cfg['k_5'], cfg['k_5']), strides=(cfg['s_2'], cfg['s_2']), padding='same', kernel_regularizer=l2(cfg['l2']), bias_regularizer=l2(cfg['l2']))(layer) else: layer = MaxPooling2D(pool_size=(cfg['k_5'], cfg['k_5']), strides=(cfg['s_2'], cfg['s_2']), padding='same')(layer) layer = Activation(cfg['activation'])(layer) layer = Dropout(cfg['dropout_3'])(layer) layer = skip_manager.connect_skip(layer) #stack 3 for i in range(cfg['stack_3']): layer = Conv2D(cfg['filters_6'], (cfg['k_6'], cfg['k_6']), padding='same', kernel_regularizer=l2(cfg['l2']), bias_regularizer=l2(cfg['l2']))(layer) layer = Activation(cfg['activation'])(layer) layer = skip_manager.connect_skip(layer) if (cfg['stack_3'] > 0): if (cfg['no_pooling']): layer = Conv2D(cfg['filters_7'], (cfg['k_7'], cfg['k_7']), strides=(cfg['s_3'], cfg['s_3']), padding='same', kernel_regularizer=l2(cfg['l2']), bias_regularizer=l2(cfg['l2']))(layer) else: layer = MaxPooling2D(pool_size=(cfg['k_7'], cfg['k_7']), strides=(cfg['s_3'], cfg['s_3']), padding='same')(layer) layer = Activation(cfg['activation'])(layer) layer = Dropout(cfg['dropout_4'])(layer) layer = skip_manager.connect_skip(layer) #stack 4 for i in range(cfg['stack_4']): layer = Conv2D(cfg['filters_8'], (cfg['k_8'], cfg['k_8']), padding='same', kernel_regularizer=l2(cfg['l2']), bias_regularizer=l2(cfg['l2']))(layer) layer = Activation(cfg['activation'])(layer) layer = skip_manager.connect_skip(layer) if (cfg['stack_4'] > 0): if (cfg['no_pooling']): layer = Conv2D(cfg['filters_9'], (cfg['k_9'], cfg['k_9']), strides=(cfg['s_4'], cfg['s_4']), padding='same', kernel_regularizer=l2(cfg['l2']), bias_regularizer=l2(cfg['l2']))(layer) else: layer = MaxPooling2D(pool_size=(cfg['k_9'], cfg['k_9']), strides=(cfg['s_4'], cfg['s_4']), padding='same')(layer) layer = Activation(cfg['activation'])(layer) layer = Dropout(cfg['dropout_5'])(layer) layer = skip_manager.connect_skip(layer) #stack 5 for i in range(cfg['stack_5']): layer = Conv2D(cfg['filters_10'], (cfg['k_10'], cfg['k_10']), padding='same', kernel_regularizer=l2(cfg['l2']), bias_regularizer=l2(cfg['l2']))(layer) layer = Activation(cfg['activation'])(layer) layer = skip_manager.connect_skip(layer) if (cfg['stack_5'] > 0): if (cfg['no_pooling']): layer = Conv2D(cfg['filters_11'], (cfg['k_11'], cfg['k_11']), strides=(cfg['s_5'], cfg['s_5']), padding='same', kernel_regularizer=l2(cfg['l2']), bias_regularizer=l2(cfg['l2']))(layer) else: layer = MaxPooling2D(pool_size=(cfg['k_11'], cfg['k_11']), strides=(cfg['s_5'], cfg['s_5']), padding='same')(layer) layer = Activation(cfg['activation'])(layer) layer = Dropout(cfg['dropout_6'])(layer) layer = skip_manager.connect_skip(layer) #stack 6 for i in range(cfg['stack_6']): layer = Conv2D(cfg['filters_12'], (cfg['k_12'], cfg['k_12']), padding='same', kernel_regularizer=l2(cfg['l2']), bias_regularizer=l2(cfg['l2']))(layer) layer = Activation(cfg['activation'])(layer) layer = skip_manager.connect_skip(layer) if (cfg['stack_6'] > 0): if (cfg['no_pooling']): layer = Conv2D(cfg['filters_13'], (cfg['k_13'], cfg['k_13']), strides=(cfg['s_6'], cfg['s_6']), padding='same', kernel_regularizer=l2(cfg['l2']), bias_regularizer=l2(cfg['l2']))(layer) else: layer = MaxPooling2D(pool_size=(cfg['k_13'], cfg['k_13']), strides=(cfg['s_6'], cfg['s_6']), padding='same')(layer) layer = Activation(cfg['activation'])(layer) layer = Dropout(cfg['dropout_7'])(layer) layer = skip_manager.connect_skip(layer) #global averaging if (cfg['global_pooling']): layer = GlobalAveragePooling2D()(layer) else: layer = Flatten()(layer) #head if cfg['dense_size_0'] > 0: layer = Dense(cfg['dense_size_0'], kernel_regularizer=l2(cfg['l2']), bias_regularizer=l2(cfg['l2']))(layer) layer = Activation(cfg['activ_dense'])(layer) if cfg['dense_size_1'] > 0: layer = Dense(cfg['dense_size_1'], kernel_regularizer=l2(cfg['l2']), bias_regularizer=l2(cfg['l2']))(layer) layer = Activation(cfg['activ_dense'])(layer) layer = Dense(num_classes, kernel_regularizer=l2(cfg['l2']), bias_regularizer=l2(cfg['l2']))(layer) layer = Activation(cfg['activ_dense'])(layer) cfg['decay'] = cfg['lr'] / float(epochs) def step_decay(epoch): initial_lrate = cfg['lr'] drop = 0.1 epochs_drop = 20.0 lrate = initial_lrate * math.pow(drop, math.floor((1 + epoch) / epochs_drop)) return lrate callbacks = [] if (cfg['step'] == True): callbacks = [LearningRateScheduler(step_decay)] cfg['decay'] = 0. # initiate RMSprop optimizer #opt = keras.optimizers.rmsprop(lr= cfg['lr'], decay=cfg['decay']) opt = keras.optimizers.SGD(lr=cfg['lr'], momentum=0.9, decay=cfg['decay'], nesterov=False) model = keras.models.Model(inputs=input1, outputs=layer) # Let's train the model using RMSprop model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy']) if test: return model #TODO remove this, just for testing #print("amount of parameters:") #print(model.count_params()) #CHRIS test if gpu has enough memory nvmlInit() handle = nvmlDeviceGetHandleByIndex(int(gpu_no)) meminfo = nvmlDeviceGetMemoryInfo(handle) #max_size = meminfo.total #6689341440 if meminfo.free / 1024.**2 < 1.0: print('gpu is allready in use') nvmlShutdown() #if model.count_params()*4*2 >= max_size:#CHRIS *4*2: 4 byte per parameter times 2 for backpropagation #print('network too large for memory') #return 1000000000.0*(model.count_params()*4*2/max_size), 5.0*(model.count_params()*4*2/max_size) #max_size = 32828802 * 2 #CHRIS twice as large as RESnet-34-like implementation #max_size = 129200130 #CHRIS twice as wide as RESnet-34-like implementation with batchsize=10, one network of this size was able to be ran on tritanium gpu max_size = 130374394 #CHRIS twice as wide as RESnet-34-like implementation with batchsize=100, one network of this size was able to be ran on tritanium gpu #if model.count_params() > max_size: #print('network too large for implementation') #return 1000000000.0*(model.count_params()/max_size), 5.0*(model.count_params()/max_size) x_train = x_train.astype('float32') x_test = x_test.astype('float32') x_train /= 255. x_test /= 255. hist_func = TimedAccHistory() if not data_augmentation: print('Not using data augmentation.') start = time.time() hist = model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_data=(x_test, y_test), callbacks=[hist_func], verbose=verbose, shuffle=True) stop = time.time() else: print('Using real-time data augmentation.') # This will do preprocessing and realtime data augmentation: datagen = ImageDataGenerator( featurewise_center=False, # set input mean to 0 over the dataset samplewise_center=False, # set each sample mean to 0 featurewise_std_normalization= False, # divide inputs by std of the dataset samplewise_std_normalization=False, # divide each input by its std zca_whitening=False, # apply ZCA whitening rotation_range= 0, # randomly rotate images in the range (degrees, 0 to 180) width_shift_range= 0.1, # randomly shift images horizontally (fraction of total width) height_shift_range= 0.1, # randomly shift images vertically (fraction of total height) horizontal_flip=True, # randomly flip images vertical_flip=False) # randomly flip images datagen.fit(x_train) # Fit the model on the batches generated by datagen.flow(). start = time.time() hist = model.fit_generator(datagen.flow(x_train, y_train, batch_size=batch_size), verbose=verbose, callbacks=callbacks, epochs=epochs, steps_per_epoch=len(x_train) / batch_size, validation_data=(x_test, y_test)) stop = time.time() timer = stop - start #print('run-time:') #print(timer) hist_save.append([hist.history['val_acc'], hist_func.timed]) if savemodel: model.save('best_model_mnist.h5') maxval = max(hist.history['val_acc']) #loss = -1 * math.log( 1.0 - max(hist.history['val_acc']) ) #np.amin(hist.history['val_loss']) loss = -1 * math.log(max(hist.history['val_acc']) ) #CHRIS minimizing this will maximize accuracy #print('max val_acc:') #print(max(hist.history['val_acc'])) #print('loss:') #print(loss) #perf5 = max(hist.history['val_top_5_categorical_accuracy']) if logfile is not None: log_file = logfile #os.path.join(data_des, logfile) cfg_df['perf'] = maxval # save the configurations to log file if os.path.isfile(log_file): cfg_df.to_csv(log_file, mode='a', header=False, index=False) else: cfg_df.to_csv(log_file, mode='w', header=True, index=False) return timer, loss
from keras.datasets import cifar10 import matplotlib.pyplot as plt import keras.utils as utils import numpy as np def reshape_image(input_image_arrays): output_array = [] for image_array in input_image_arrays: output_array.append(image_array.reshape(-1)) return np.asarray(output_array) (train_images, train_labels), (test_images, test_labels) = cifar10.load_data() first_image = train_images[4] # print(first_image[0]) # plt.imshow(first_image) # plt.show() labels_array = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck'] train_labels = utils.to_categorical(train_labels) test_labels = utils.to_categorical(test_labels) first_label_index = train_labels[0][0] max_index = np.argmax(train_labels[0]) max_index = np.argmax(train_labels[0]) print(labels_array[max_index])
from keras.layers import Dense, Activation, Dropout from keras.callbacks import TensorBoard from time import strftime from sklearn.metrics import confusion_matrix # CONSTANTS LABEL_Names = ['Plane', 'Car', 'Bird', 'Cat', 'Deer', 'Dog', 'Frog', 'Horse', 'Ship', 'Truck'] IMG_Width = 32 IMG_Height = 32 IMG_Pix = IMG_Height*IMG_Width COLOR_Channels = 3 #RGB TOTAL_Inputs =IMG_Pix * COLOR_Channels VALIDATION_Size = 10000 LOG_Dir = 'tensorboard_cifar_logs/' #there are folder with logs from learning (x_train_all, y_train_all),(x_test, y_test) = cifar10.load_data() pic = array_to_img(x_train_all[7]) #pic.show() #print(y_train_all.shape) #print(y_train_all[7][0]) #print(LABEL_NAMES[y_train_all[7][0]]) #plt.imshow(x_train_all[4]) #plt.xlabel(LABEL_NAMES[y_train_all[4][0]]) #plt.show() #showing images #for i in range (10): #print(LABEL_NAMES[y_train_all[i][0]]) #plt.imshow(x_train_all[i]) #plt.xlabel(LABEL_NAMES[y_train_all[i][0]])
from keras.preprocessing.image import ImageDataGenerator from keras.models import Sequential from keras.layers import Dense, Dropout, Activation, Flatten from keras.layers import Conv2D, MaxPooling2D import os batch_size = 32 num_classes = 10 epochs = 100 num_predictions = 20 save_dir = os.path.join(os.getcwd(), 'saved_models') model_name = 'keras_cifar10_trained_model.h5' # The data, split between train and test sets: (x_tr, y_tr), (x_test, y_test) = cifar10.load_data() print('x_train shape:', x_tr.shape) print(x_tr.shape[0], 'train samples') print(x_test.shape[0], 'test samples') # Convert class vectors to binary class matrices. y_tr = keras.utils.to_categorical(y_tr, num_classes) y_test = keras.utils.to_categorical(y_test, num_classes) convNetModel = Sequential() convNetModel.add(Conv2D(32, (3, 3), padding='same', input_shape=x_tr.shape[1:])) convNetModel.add(Activation('relu')) convNetModel.add(Conv2D(32, (3, 3))) convNetModel.add(Activation('relu')) convNetModel.add(MaxPooling2D(pool_size=(2, 2)))
percent = self.i * 100.0 / self.max_steps # 计算完成进度,格式为xx.xx% process_bar = '\r[' + '>' * num_arrow + '-' * num_line + ']' \ + '%.2f' % percent + '% ' + info # 带输出的字符串,'\r'表示不换行回到最左边 print(process_bar, end='') # 这两句打印字符到终端 if self.i > self.max_steps: self.close() def close(self): print("\n") self.i = 0 batch_size = 128 import numpy as np (x_train, y_train), (x_test, y_test) = load_data() # 50000, 32,32,3 y_train = np.array(keras.utils.to_categorical(y_train, 10).tolist()) y_test = np.array(keras.utils.to_categorical(y_test, 10).tolist()) x_train, x_test = color_preprocessing(x_train, x_test) x = tf.placeholder(tf.float32, [None, 32, 32, 3]) y = tf.placeholder(tf.float32, [None, 10]) with slim.arg_scope(resnet_arg_scope(is_training=True)): net, end_points = resnet_v2_32(x, 10) # 分辨率会缩小32倍 loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=net)) update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) global_step = tf.Variable(0, trainable=False) learning_rate = tf.train.exponential_decay(0.1, global_step, 4000000, 0.1) with tf.control_dependencies(update_ops):
def run(epochs, batch_size, lr, gpus, data_augmentation, cpu_relocation, cpu_merge): time_reporter = StepTimeReporter() # img_arr is of shape (n, h, w, c) def resize_image_arr(img_arr): x_resized_list = [] for i in range(img_arr.shape[0]): img = img_arr[i] resized_img = resize(img, (224, 224)) x_resized_list.append(resized_img) return np.stack(x_resized_list) (x_train, y_train), (x_test, y_test) = cifar10.load_data() x_train = x_train[:2048] y_train = y_train[:2048] x_test = x_test[:2048] y_test = y_test[:2048] print("Resizing images") # Resize image arrays x_train = resize_image_arr(x_train) x_test = resize_image_arr(x_test) NUM_CLASSES = 10 # Convert class vectors to binary class matrices. y_train = keras.utils.to_categorical(y_train, NUM_CLASSES) y_test = keras.utils.to_categorical(y_test, NUM_CLASSES) # Normalize the data x_train = x_train.astype('float32') x_test = x_test.astype('float32') x_train /= 255 x_test /= 255 model = ResNet50(include_top=True, weights=None, classes=10) STEPS = 2 if random.choice([True, False]): opt = keras.optimizers.SGD(lr=lr) opt = runai.ga.keras.optimizers.Optimizer(opt, STEPS) else: opt = runai.ga.keras.optimizers.SGD(STEPS, lr=lr) opt = hvd.DistributedOptimizer(opt) # Not needed to change the device scope for model definition: model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy']) if not data_augmentation: model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_data=(x_test, y_test), shuffle=False) else: datagen = ImageDataGenerator( featurewise_center=False, # set input mean to 0 over the dataset samplewise_center=False, # set each sample mean to 0 featurewise_std_normalization= False, # divide inputs by std of the dataset samplewise_std_normalization=False, # divide each input by its std zca_whitening=False, # apply ZCA whitening rotation_range= 0, # randomly rotate images in the range (degrees, 0 to 180) width_shift_range= 0, # randomly shift images horizontally (fraction of total width) height_shift_range= 0, # randomly shift images vertically (fraction of total height) horizontal_flip=True, # randomly flip images vertical_flip=False) # randomly flip images # Compute quantities required for feature-wise normalization # (std, mean, and principal components if ZCA whitening is applied). datagen.fit(x_train) # Fit the model on the batches generated by datagen.flow(). model.fit_generator( datagen.flow(x_train, y_train, batch_size=batch_size), steps_per_epoch=int(10 * x_train.shape[0] / batch_size), epochs=epochs, validation_data=(x_test, y_test), workers=1, callbacks=[ time_reporter, hvd.callbacks.BroadcastGlobalVariablesCallback(0) ]) print("BYE BYE")
def train(argv=None): ''' train conditional Gated PixelCNN model Usage: python train_keras_datasets.py -c sample_train.cfg : training example using configfile python train_keras_datasets.py --option1 hoge ... : train with command-line options python train_keras_datasets.py -c test.cfg --opt1 hoge... : overwrite config options with command-line options ''' ### parsing arguments from command-line or config-file ### if argv is None: argv = sys.argv conf_parser = argparse.ArgumentParser( description=__doc__, # printed with -h/--help formatter_class=argparse.RawDescriptionHelpFormatter, add_help=False) conf_parser.add_argument("-c", "--conf_file", help="Specify config file", metavar="FILE_PATH") args, remaining_argv = conf_parser.parse_known_args() defaults = {} if args.conf_file: config = configparser.SafeConfigParser() config.read([args.conf_file]) defaults.update(dict(config.items("General"))) parser = argparse.ArgumentParser(parents=[conf_parser]) parser.set_defaults(**defaults) parser.add_argument("--nb_epoch", help="Number of epochs [Required]", type=int, metavar="INT") parser.add_argument("--batch_size", help="Minibatch size", type=int, metavar="INT") parser.add_argument( "--conditional", help="model the conditional distribution p(x|h) (default:False)", type=str, metavar="BOOL") parser.add_argument("--dataset_name", help="{'mnist', 'cifar10', 'cifar100'}", type=str, metavar="DATASET_NAME") parser.add_argument( "--nb_pixelcnn_layers", help="Number of PixelCNN Layers (exept last two ReLu layers)", metavar="INT") parser.add_argument("--nb_filters", help="Number of filters for each layer", metavar="INT") parser.add_argument( "--filter_size_1st", help="Filter size for the first layer. (default: (7,7))", metavar="INT,INT") parser.add_argument( "--filter_size", help="Filter size for the subsequent layers. (default: (3,3))", metavar="INT,INT") parser.add_argument("--optimizer", help="SGD optimizer (default: adadelta)", type=str, metavar="OPT_NAME") parser.add_argument("--es_patience", help="Patience parameter for EarlyStopping", type=int, metavar="INT") parser.add_argument( "--save_root", help= "Root directory which trained files are saved (default: /tmp/pixelcnn)", type=str, metavar="DIR_PATH") parser.add_argument( "--timezone", help= "Trained files are saved in save_root/YYYYMMDDHHMMSS/ (default: Asia/Tokyo)", type=str, metavar="REGION_NAME") parser.add_argument( "--save_best_only", help="The latest best model will not be overwritten (default: False)", type=str, metavar="BOOL") parser.add_argument("--plot_model", help="If True, plot a Keras model (using graphviz)", type=str, metavar="BOOL") args = parser.parse_args(remaining_argv) conditional = strtobool(args.conditional) if args.conditional else False try: dataset_name = args.dataset_name except: sys.exit("Error: --dataset_name must be specified.") ### load keras dataset ### if dataset_name == 'mnist': from keras.datasets import mnist (X_train, h_train), (X_validation, h_validation) = mnist.load_data() input_size = (28, 28) nb_classes = 10 nb_channels = 1 elif dataset_name == 'cifar10': from keras.datasets import cifar10 (X_train, h_train), (X_validation, h_validation) = cifar10.load_data() input_size = (32, 32) nb_classes = 10 nb_channels = 3 elif dataset_NAME == 'cifar100': from keras.datasets import cifar100 (X_train, h_train), (X_validation, h_validation) = cifar100.load_data() input_size = (32, 32) nb_classes = 100 nb_channels = 3 utils = Utils() ### build PixelCNN model ### model_params = {} model_params['input_size'] = input_size model_params['nb_channels'] = nb_channels model_params['conditional'] = conditional if conditional: model_params['latent_dim'] = nb_classes if args.nb_pixelcnn_layers: model_params['nb_pixelcnn_layers'] = int(args.nb_pixelcnn_layers) if args.nb_filters: model_params['nb_filters'] = int(args.nb_filters) if args.filter_size_1st: model_params['filter_size_1st'] = tuple( map(int, args.filter_size_1st.split(','))) if args.filter_size: model_params['filter_size'] = tuple( map(int, args.filter_size.split(','))) if args.optimizer: model_params['optimizer'] = args.optimizer if args.es_patience: model_params['es_patience'] = int(args.patience) if args.save_best_only: model_params['save_best_only'] = strtobool(args.save_best_only) save_root = args.save_root if args.save_root else '/tmp/pixelcnn_' + dataset_name timezone = args.timezone if args.timezone else 'Asia/Tokyo' current_datetime = datetime.now( pytz.timezone(timezone)).strftime('%Y%m%d_%H%M%S') save_root = os.path.join(save_root, current_datetime) model_params['save_root'] = save_root if not os.path.exists(save_root): os.makedirs(save_root) try: nb_epoch = int(args.nb_epoch) batch_size = int(args.batch_size) except: sys.exit("Error: {--nb_epoch, --batch_size} must be specified.") pixelcnn = PixelCNN(**model_params) pixelcnn.build_model() pixelcnn.model.summary() pixelcnn.print_train_parameters(save_root) pixelcnn.export_train_parameters(save_root) with open(os.path.join(save_root, 'parameters.txt'), 'a') as txt_file: txt_file.write('########## other options ##########\n') txt_file.write('nb_epoch\t: %s\n' % nb_epoch) txt_file.write('batch_size\t: %s\n' % batch_size) txt_file.write('\n') plot_model = strtobool(args.plot_model) if args.plot_model else True if plot_model: plot(pixelcnn.model, to_file=os.path.join(save_root, 'pixelcnn_model.png')) if conditional: train_generator = utils.build_data_generator_from_keras_datasets( dataset_name, X_train, h_train, batch_size) validation_generator = utils.build_data_generator_from_keras_datasets( dataset_name, X_validation, h_validation, batch_size) else: train_generator = utils.build_data_generator_from_keras_datasets( dataset_name, X_train, None, batch_size) validation_generator = utils.build_data_generator_from_keras_datasets( dataset_name, X_validation, None, batch_size) nb_train_samples = len(X_train) nb_validation_samples = len(X_validation) pixelcnn.fit_generator(train_generator=train_generator, samples_per_epoch=nb_train_samples, nb_epoch=nb_epoch, validation_data=validation_generator, nb_val_samples=nb_validation_samples) return (0)
Aprendizagem não supervisionada Redução de dimensionalidade - Tarefa Base de dados CIFAR10 Construção de um autoencoder para redimensionamento, codificação e decodificação de imagens """ import numpy as np import matplotlib.pyplot as plt from keras.datasets import cifar10 from keras.models import Model, Sequential from keras.layers import Input, Dense import os os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' (previsores_treinamento, _), (previsores_teste, _) = cifar10.load_data() previsores_treinamento = previsores_treinamento.astype('float32') / 255 previsores_teste = previsores_teste.astype('float32') / 255 previsores_treinamento = previsores_treinamento.reshape( (len(previsores_treinamento), np.prod(previsores_treinamento.shape[1:]))) previsores_teste = previsores_teste.reshape( (len(previsores_teste), np.prod(previsores_teste.shape[1:]))) """ Algoritmo para o treinamento """ # 3072 - 1536 - 768 - 1536 - 3072 autoencoder = Sequential() # Encode autoencoder.add(Dense(units=1536, activation='relu', input_dim=3072)) autoencoder.add(Dense(units=768, activation='relu'))
def main(): args = parse_args() if args.name is None: args.name = 'WideResNet%s-%s' % (args.depth, args.width) if args.scheduler == 'CosineAnnealing': args.name += '_wCosineAnnealing' if not os.path.exists('models/%s' % args.name): os.makedirs('models/%s' % args.name) print('Config -----') for arg in vars(args): print('%s: %s' % (arg, getattr(args, arg))) print('------------') with open('models/%s/args.txt' % args.name, 'w') as f: for arg in vars(args): print('%s: %s' % (arg, getattr(args, arg)), file=f) joblib.dump(args, 'models/%s/args.pkl' % args.name) # create model model = WideResNet(args.depth, args.width, num_classes=10) model.compile(loss='categorical_crossentropy', optimizer=SGD(lr=0.1, momentum=0.9), metrics=['accuracy']) (x_train, y_train), (x_test, y_test) = cifar10.load_data() x_train = x_train.astype('float32') / 255 x_test = x_test.astype('float32') / 255 x_train = standardize(x_train) x_test = standardize(x_test) datagen = ImageDataGenerator(width_shift_range=0.1, height_shift_range=0.1, horizontal_flip=True) y_train = keras.utils.to_categorical(y_train, 10) y_test = keras.utils.to_categorical(y_test, 10) callbacks = [ ModelCheckpoint('models/%s/model.hdf5' % args.name, verbose=1, save_best_only=True), CSVLogger('models/%s/log.csv' % args.name) ] if args.scheduler == 'CosineAnnealing': callbacks.append( CosineAnnealingScheduler(T_max=args.epochs, eta_max=0.05, eta_min=4e-4)) else: callbacks.append(LearningRateScheduler(adjust_learning_rate)) model.fit_generator(datagen.flow(x_train, y_train, batch_size=args.batch_size), steps_per_epoch=len(x_train) // args.batch_size, validation_data=(x_test, y_test), epochs=args.epochs, verbose=1, workers=4, callbacks=callbacks) scores = model.evaluate(x_test, y_test, verbose=1) print('Test loss:', scores[0]) print('Test accuracy:', scores[1])
def train(self, epochs, batch_size=128, save_interval=50): # Charger les données (X_train, y_train), (_, _) = cifar10.load_data() X_train = np.array( X_train[np.argwhere(y_train.squeeze() == 5)].squeeze()) # Redimensionnement de -1 à 1 X_train = X_train / 127.5 - 1. if self.channels == 1: X_train = np.expand_dims( X_train, axis=3 ) # S'il y a un seul channel, il faut expand les dimensions de l'ensemble d'entraînement # Adversarial ground truths valid = np.ones((batch_size, 1)) fake = np.zeros((batch_size, 1)) f = open(self.savePath + "data.csv", "a+") f.write( "Time, Epoch, DiscriminatorLoss, DiscriminatorAcc, GeneratorLoss\n" ) f.close() debut = time.time() for epoch in range(epochs): # ---------------------------- # Entraînement Discriminateur # ---------------------------- # Choisir une batch aléatoire d'images idx = np.random.randint(0, X_train.shape[0], batch_size) imgs = X_train[idx] # Échantillonner le bruit et générer une batch de nouvelles images noise = np.random.normal(0, 1, (batch_size, self.latent_dim)) gen_imgs = self.generator.predict(noise) # Entraîner le discriminateur (vrai classifié comme 1 et généré comme 0) d_loss_real = self.discriminator.train_on_batch(imgs, valid) d_loss_fake = self.discriminator.train_on_batch(gen_imgs, fake) d_loss = 0.5 * np.add(d_loss_real, d_loss_fake) # ------------------------ # Entraînement Générateur # ------------------------ # Entraîner le générateur (pour que le discriminateur n'arrive pas à discerner les fausses images) g_loss = self.combined.train_on_batch(noise, valid) # Progression if epoch % 10 == 0: delta = time.time() - debut f = open(self.savePath + "data.csv", "a+") print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (epoch, d_loss[0], 100 * d_loss[1], g_loss)) f.write("%.3f, %d, %f, %.2f, %f\n" % (delta, epoch, d_loss[0], 100 * d_loss[1], g_loss)) f.close() # Selon l'intervalle de sauvegarde, on sauvegarde les images générées if epoch % save_interval == 0: self.save_imgs(epoch)
def process_model(model, dataset, normalise, weight_prune, relu_prune, do_eval, add_svm_dists, output_path, epsilon, weight_prune_threshold=1e-3, relu_prune_threshold=0.05, validation_size=5000): if dataset == "CIFAR10": (x_train, y_train), _ = cifar10.load_data() y_train = y_train.reshape(-1) num_classes = 10 elif dataset == "MNIST": (x_train, y_train), _ = mnist.load_data() x_train = np.expand_dims(x_train, axis=-1) num_classes = 10 elif dataset == "FASHION_MNIST": (x_train, y_train), _ = fashion_mnist.load_data() x_train = np.expand_dims(x_train, axis=-1) num_classes = 10 else: raise ValueError("Unrecognised dataset") # Leave aside a validation set x_valid = x_train[-validation_size:] y_valid = y_train[-validation_size:] x_train = x_train[:-validation_size] y_train = y_train[:-validation_size] # Normalize data x_train = x_train.astype("float32") / 255 x_valid = x_valid.astype("float32") / 255 if normalise: mean = x_train.mean(axis=(0, 1, 2)) std = x_train.std(axis=(0, 1, 2)) + 1e-8 print("Normalising channels with values", mean, std) input_shape = x_train.shape[1:] normalise_input = Input(shape=input_shape, name="input_for_normalise") normalise_layer = Lambda(lambda x: (x - K.constant(mean)) / K.constant(std)) normalise_layer.mean = mean normalise_layer.std = std output = normalise_layer(normalise_input) for l in model._layers[1:]: output = l(output) model = Model(inputs=normalise_input, outputs=output) model.compile(loss="sparse_categorical_crossentropy", optimizer=Adam(lr=1e-4), metrics=["accuracy"]) if do_eval: evaluate(model, x_valid, y_valid) if weight_prune: prune_small_weights(model, weight_prune_threshold) if do_eval: evaluate(model, x_valid, y_valid) if relu_prune: relu_pruned_model, layer_ops = prune_relus(model, relu_prune_threshold, x_train, y_train, epsilon) if do_eval: evaluate(relu_pruned_model, x_valid, y_valid) if add_svm_dists: model = add_svm_distances(model, x_train, y_train, num_classes=num_classes) # Save processed model layer_config = [] weights_to_save = {} relu_layers = [ l for l in model._layers if isinstance(l, ReLU) or (isinstance(l, Activation) and l.activation == activations.get("relu")) ] for i, layer in enumerate(model._layers): input_layers = [] for n in layer._inbound_nodes: input_layers.extend(n.inbound_layers) # input_indices = [model._layers.index(l) for l in input_layers] input_indices = [model._layers.index(input_layers[-1]) ] if len(input_layers) > 0 else [] if isinstance(layer, InputLayer): layer_config.append({"type": "Input"}) elif isinstance(layer, Add): assert (len(input_indices) == 2) layer_config.append({"type": "Add"}) elif isinstance(layer, AveragePooling2D): assert (len(input_indices) == 1) layer_config.append({ "type": "AveragePool", "pool_size": layer.pool_size }) elif isinstance(layer, BatchNormalization): assert (len(input_indices) == 1) layer_id = "Normalization_{}".format(i) [gamma, beta, mm, mv] = layer.get_weights() eps = layer.epsilon weights_to_save[layer_id + "/mean"] = mm weights_to_save[layer_id + "/std"] = np.sqrt(mv + eps) weights_to_save[layer_id + "/gamma"] = gamma weights_to_save[layer_id + "/beta"] = beta layer_config.append({"type": "Normalization"}) elif isinstance(layer, Conv2D): assert (len(input_indices) == 1) layer_id = "Conv2D_{}".format(i) [weights, bias] = layer.get_weights() weights_to_save[layer_id + "/weight"] = weights weights_to_save[layer_id + "/bias"] = bias layer_config.append({ "type": "Conv2D", "weight_shape": weights.shape, "stride": layer.strides, "padding": layer.padding }) elif isinstance(layer, Dense): assert (len(input_indices) == 1) layer_id = "FullyConnected_{}".format(i) [weights, bias] = layer.get_weights() weights_to_save[layer_id + "/weight"] = weights weights_to_save[layer_id + "/bias"] = bias layer_config.append({ "type": "FullyConnected", "weight_shape": weights.shape }) elif isinstance(layer, Flatten): assert (len(input_indices) == 1) layer_config.append({"type": "Flatten"}) elif isinstance(layer, MaxPooling2D): assert (len(input_indices) == 1) layer_config.append({ "type": "MaxPool", "pool_size": layer.pool_size }) elif isinstance( layer, Lambda) and layer.mean is not None and layer.std is not None: assert (len(input_indices) == 1) layer_id = "Normalization_{}".format(i) mean, std = layer.mean, layer.std weights_to_save[layer_id + "/mean"] = mean weights_to_save[layer_id + "/std"] = std weights_to_save[layer_id + "/gamma"] = np.ones_like(mean) weights_to_save[layer_id + "/beta"] = np.zeros_like(mean) layer_config.append({"type": "Normalization"}) elif layer in relu_layers: assert (len(input_indices) == 1) if relu_prune: layer_type = "MaskedRelu" layer_id = "MaskedRelu_{}".format(i) index = relu_layers.index(layer) ops = layer_ops[index] weights_to_save[layer_id + "/mask"] = layer_ops[index] else: layer_type = "Relu" layer_config.append({"type": layer_type}) elif isinstance(layer, Softmax) and i == len(model._layers) - 1: pass else: raise ValueError("Unsupported layer") layer_config[-1]["input_indices"] = input_indices output_config_path = str(output_path) + "__config.json" output_weights_path = str(output_path) + "__weights.mat" with open(str(output_config_path), "w") as outfile: json.dump(layer_config, outfile) sio.savemat(str(output_weights_path), weights_to_save) print("Saved processed model in:") print(" " + str(output_config_path)) print(" " + str(output_weights_path))
import matplotlib.pyplot as plt import time # Some hyperparameters num_epcohs = 500 lr_discrim = 0.0002 beta_1_discrim = 0.5 lr_gen = 0.0002 beta_1_gen = 0.5 batch_size = 100 z_dim = 100 CONTINUE_TRAINING = True start_point = 0 # load the parameter (train_X, _), (_, _) = cifar10.load_data() # the data configuration img_size_cifar = 32 num_channels_cifar = 3 img_size_flat_cifar = img_size_cifar * img_size_cifar * num_channels_cifar img_shape_cifar = (img_size_cifar, img_size_cifar, num_channels_cifar) num_classes_cifar = 10 # process the data train_X = train_X / 255 train_X = train_X * 2 - 1 kernel_init = tf.truncated_normal_initializer(mean=0.0, stddev=0.02)
import numpy from keras.datasets import cifar10 import numpy as np np.random.seed(10) import time import os os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' t=time.clock() (x_img_train,y_label_train), \ (x_img_test, y_label_test)=cifar10.load_data() label_dict={0:"airplane",1:"automobile",2:"bird",3:"cat",4:"deer", 5:"dog",6:"frog",7:"horse",8:"ship",9:"truck"} import matplotlib.pyplot as plt def plot_images_labels_prediction(images, labels, prediction, idx, num=10): fig = plt.gcf() fig.set_size_inches(12, 14) if num > 16: num = 16 for i in range(0, num): ax = plt.subplot(4, 4, 1 + i) ax.imshow(images[idx], cmap='binary') title = str(i) + ',' + label_dict[labels[i][0]] if len(prediction) > 0: title += '=>' + label_dict[prediction[i]]
self.ytr = y def predict(self, X): """X = N x D where each row is an example we wish to predict label for""" num_test = X.shape[0] Ypred = np.zeros( num_test, dtype=ytr.dtype ) # lets make sure the output type matches the input type # loop over all test rows for i in range(num_test): # find the nearest training image to the i'th test image # using the L1 distance (sum of absolute value differences) distances = np.sum(np.abs(self.Xtr - X[i, :]), axis=1) min_index = np.argmin( distances) # get the index with smallest distance Ypred[i] = self.ytr[ min_index] # predict the label of the nearest example return Ypred (Xtr, ytr), (Xte, Yte) = cifar10.load_data() Xtr_rows = Xtr.reshape(Xtr.shape[0], 32 * 32 * 3) Xte_rows = Xte.reshape(Xte.shape[0], 32 * 32 * 3) nn = NearestNeighbor() # create a Nearest Neighbor classifier class nn.train(Xtr_rows, ytr) # train the classifier on the training images and labels Yte_predict = nn.predict(Xte_rows) # predict labels on the test images print('Accuracy: {}'.format(np.mean(Yte_predict=Yte)))
def app(): # The data, shuffled and split between train and test sets: (x_train, y_train), (x_test, y_test) = cifar10.load_data() print('x_train shape:', x_train.shape) print(x_train.shape[0], 'train samples') print(x_test.shape[0], 'test samples') print(x_train.shape[1:]) # Convert class vectors to binary class matrices. y_train = keras.utils.to_categorical(y_train, num_classes) y_test = keras.utils.to_categorical(y_test, num_classes) model = get_model() # initiate RMSprop optimizer opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6) # Let's train the model using RMSprop model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy']) x_train = x_train.astype('float32') x_test = x_test.astype('float32') x_train /= 255 x_test /= 255 return x_train if not data_augmentation: print('Not using data augmentation.') model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_data=(x_test, y_test), shuffle=True) else: print('Using real-time data augmentation.') # This will do preprocessing and realtime data augmentation: datagen = ImageDataGenerator( featurewise_center=False, # set input mean to 0 over the dataset samplewise_center=False, # set each sample mean to 0 featurewise_std_normalization= False, # divide inputs by std of the dataset samplewise_std_normalization=False, # divide each input by its std zca_whitening=False, # apply ZCA whitening rotation_range= 0, # randomly rotate images in the range (degrees, 0 to 180) width_shift_range= 0.1, # randomly shift images horizontally (fraction of total width) height_shift_range= 0.1, # randomly shift images vertically (fraction of total height) horizontal_flip=True, # randomly flip images vertical_flip=False) # randomly flip images # Compute quantities required for feature-wise normalization # (std, mean, and principal components if ZCA whitening is applied). datagen.fit(x_train) # Fit the model on the batches generated by datagen.flow(). model.fit_generator(datagen.flow(x_train, y_train, batch_size=batch_size), steps_per_epoch=x_train.shape[0] // batch_size, epochs=epochs, validation_data=(x_test, y_test)) # Save model and weights if not os.path.isdir(save_dir): os.makedirs(save_dir) model_path = os.path.join(save_dir, model_name) model.save(model_path) print('Saved trained model at %s ' % model_path) # Load label names to use in prediction results label_list_path = 'datasets/cifar-10-batches-py/batches.meta' keras_dir = os.path.expanduser(os.path.join('~', '.keras')) datadir_base = os.path.expanduser(keras_dir) if not os.access(datadir_base, os.W_OK): datadir_base = os.path.join('/tmp', '.keras') label_list_path = os.path.join(datadir_base, label_list_path) with open(label_list_path, mode='rb') as f: labels = pickle.load(f) # Evaluate model with test data set and share sample prediction results evaluation = model.evaluate_generator(datagen.flow(x_test, y_test, batch_size=batch_size), steps=x_test.shape[0] // batch_size) print('Model Accuracy = %.2f' % (evaluation[1])) predict_gen = model.predict_generator(datagen.flow(x_test, y_test, batch_size=batch_size), steps=x_test.shape[0] // batch_size) for predict_index, predicted_y in enumerate(predict_gen): actual_label = labels['label_names'][np.argmax(y_test[predict_index])] predicted_label = labels['label_names'][np.argmax(predicted_y)] print('Actual Label = %s vs. Predicted Label = %s' % (actual_label, predicted_label)) if predict_index == num_predictions: break
hang_all_str.summary() return hang_all_str hang_all_str = hang_net() #set parameter class number,weight decay(wd),momentum(rush) hang_kinds = 10 hang_iter = 1 hang_block = 64 hang_wd = 0 hang_rush = 0.93 hang_rate = 0.006 # Load the CIFAR10 data. (hangtr, hangtr_label), (hangte, hangte_label) = cifar10.load_data() #shrink train data #hangtr_remain, hangtr, hangtr_label_remain, hangtr_label = \ #train_test_split(hangtr, hangtr_label, test_size=12500, stratify=hangtr_label) print("traning sample number:", hangtr.shape) # data pre process.cahnge class vector to binary class matrix. hangtr_label = keras.utils.to_categorical(hangtr_label, hang_kinds) hangte_label = keras.utils.to_categorical(hangte_label, hang_kinds) sgd = optimizers.SGD(lr=hang_rate, decay=hang_wd, momentum=hang_rush, nesterov=True) hang_all_str.compile(loss='categorical_crossentropy', optimizer=sgd,
def load_dataset(dset, normalize_data, options): if dset == 'mnist': # input image dimensions img_rows, img_cols = 28, 28 # the data, split between train and test sets (x_train, y_train), (x_test, y_test) = mnist.load_data() print(x_train.shape) n_channels = 1 elif dset == 'cifar10': img_rows, img_cols = 32, 32 n_channels = 3 (x_train, y_train), (x_test, y_test) = cifar10.load_data() elif dset == 'fashion': img_rows, img_cols = 28, 28 n_channels = 1 (x_train, y_train), (x_test, y_test) = fashion_mnist.load_data() elif dset == 'mnist-clut': img_rows, img_cols = 60, 60 # the data, split between train and test sets #folder='/media/home/rdata/image/' folder = '/home/btek/datasets/image/' data = np.load(folder + "mnist_cluttered_60x60_6distortions.npz", allow_pickle=True) y_trn = data['y_train'] y_val = data['y_valid'] y_tst = data['y_test'] x_train, y_train = data['x_train'], np.argmax(y_trn, axis=-1) x_valid, y_valid = data['x_valid'], np.argmax(y_val, axis=-1) x_test, y_test = data['x_test'], np.argmax(y_tst, axis=-1) x_train = np.vstack((x_train, x_valid)) y_train = np.concatenate((y_train, y_valid)) n_channels = 1 normalize_data = False # this dataset is already somehow normalized #decay_epochs =[e_i*30,e_i*100] elif dset == 'lfw_faces': from sklearn.datasets import fetch_lfw_people lfw_people = fetch_lfw_people(min_faces_per_person=20, resize=0.4) # introspect the images arrays to find the shapes (for plotting) n_samples, img_rows, img_cols = lfw_people.images.shape n_channels = 1 X = lfw_people.data n_features = X.shape[1] # the label to predict is the id of the person y = lfw_people.target target_names = lfw_people.target_names num_classes = target_names.shape[0] from sklearn.model_selection import train_test_split #X -= X.mean() #X /= X.std() #split into a training and testing set x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.25) if K.image_data_format() == 'channels_first': x_train = x_train.reshape(x_train.shape[0], n_channels, img_rows, img_cols) x_test = x_test.reshape(x_test.shape[0], n_channels, img_rows, img_cols) input_shape = (n_channels, img_rows, img_cols) else: x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, n_channels) x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, n_channels) input_shape = (img_rows, img_cols, n_channels) ''' why I have written this?? BTEK if(n_channels==1): x_train = np.repeat(x_train,3, axis=3) x_test = np.repeat(x_test,3, axis=3) n_channels=3 input_shape = (img_rows, img_cols, n_channels) ''' num_classes = np.shape(np.unique(y_train))[0] x_train = x_train.astype('float32') x_test = x_test.astype('float32') if normalize_data: #Simple norm 0.1 #x_train /= 255 #x_test /= 255 #Standard norm mean 0 , std 1, per input #this normalization is very bad. BTEK for IMAGES #trn_mn = np.mean(x_train, axis=0) this normalization is very bad. BTEK for IMAGES #trn_std = np.std(x_train, axis=0) this normalization is very bad. BTEK for IMAGES # Standard for mean 127 and std per image. # This does not have 0 mean but some negative value # Std is 1.0 some paper results wer taken by this I guess # trn_mn = np.mean(x_train) # trn_std = np.std(x_train) # x_train -= 127.0 # I use this because other normalizations do not create symmetric distribution. # x_test -= 127.0 # x_train/=(trn_std+1e-7) # x_test/=(trn_std+1e-7) # print("Data normed Mean(train):", np.mean(x_train), " Std(train):", np.std(x_train)) # print("Data normed Mean(test):", np.mean(x_test), " Std(test):", np.std(x_test)) # Standard for mean 127 and std per image. # This does not have 0 mean and std is not 1.0 # Std is # x_train /= (255/4) # x_test /= (255/4) # x_train -= 2.0 # x_test -= 2.0 # print("Data normed Mean(train):", np.mean(x_train), " Std(train):", np.std(x_train)) # print("Data normed Mean(test):", np.mean(x_test), " Std(test):", np.std(x_test)) # CHANGİNG THİS aug2020 FOR FACES TEST x_train = x_train.astype('float32') x_test = x_test.astype('float32') x_train /= 255 x_test /= 255 trn_mn = np.mean(x_train, axis=0) x_train -= trn_mn x_test -= trn_mn print('x_train shape:', x_train.shape) print("Data normed Mean(train):", np.mean(x_train), " Std(train):", np.std(x_train)) print("Data normed Mean(test):", np.mean(x_test), " Std(test):", np.std(x_test)) # non-zero normalization. # trn_mn = np.mean(x_train[np.nonzero(x_train)]) # trn_std = np.std(x_train[np.nonzero(x_train)]) # x_train[np.nonzero(x_train)] -= trn_mn # x_test[np.nonzero(x_test)] -= trn_mn # print("Data normed Mean(train):", np.mean(x_train), " Std(train):", np.std(x_train)) # print("Data normed Mean(test):", np.mean(x_test), " Std(test):", np.std(x_test)) # x_train/=(trn_std+1e-7) # x_test/=(trn_std+1e-7) # print("Data normed Mean(train):", np.mean(x_train), " Std(train):", np.std(x_train)) # print("Data normed Mean(test):", np.mean(x_test), " Std(test):", np.std(x_test)) print('x_train shape:', x_train.shape) print(x_train.shape[0], 'train samples') print(x_test.shape[0], 'test samples') # convert class vectors to binary class matrices y_train = keras.utils.to_categorical(y_train, num_classes) y_test = keras.utils.to_categorical(y_test, num_classes) return x_train, y_train, x_test, y_test, input_shape, num_classes
import numpy as np import cv2 from keras.datasets import cifar10 ROOT = '/home/ninad/Desktop/DLproj/' catgs = [ 'airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck' ] (x_test, y_test) = cifar10.load_data()[1] print('Data is loaded\n') num = 1000 #to test dropout on T_mc = 100 shuff_idxs = np.load(ROOT + 'code/keras_cifar10/rand_idxs.npy') rand_idxs = shuff_idxs[:num] #take the 1st num examples xdata = x_test[rand_idxs, :, :, :] #images should be in 'uint8' format def augment_gamma(images, gamma=1.0): # build a lookup table mapping the pixel values [0, 255] to # their adjusted gamma values invGamma = 1.0 / gamma table = np.array([((i / 255.0)**invGamma) * 255 for i in np.arange(0, 256)]).astype("uint8") # apply gamma correction using the lookup table return np.asarray([cv2.LUT(img, table) for img in images])