def load_and_shuffle(data, im_size, shuffle=True): """Read csv into numpy and reshape to match image size. Works only for mnist, change image size for each use case """ y, X = np.split(data.values, (1, ), axis=1) Y = np.eye(num_classes)[y[:, 0]] X = X.reshape(-1, *im_size, 1) if shuffle: return shuffle_(X, Y) return X, Y
def hacer_blobs(n_muestras=100, n_caracteristica=2, centros=2, cluster_std=1.0, centro_caja=(-10.0, 10.0), shuffle=True, random_state=None): generador = check_random_state(random_state) if isinstance(centros, numbers.Integral): centros = generador.uniform(centro_caja[0], centro_caja[1], size=(centros, n_caracteristica)) else: centros = check_array(centros) n_caracteristica = centros.shape[1] if isinstance(cluster_std, numbers.Real): cluster_std = np.ones(len(centros)) * cluster_std X = [] y = [] n_centros = centros.shape[0] if isinstance(n_muestras, numbers.Integral): n_muestras_por_centro = [int(n_muestras // n_centros)] * n_centros for i in range(n_muestras % n_centros): n_muestras_por_centro[i] += 1 else: n_muestras_por_centro = n_muestras for i, (n, std) in enumerate(zip(n_muestras_por_centro, cluster_std)): X.append(centros[i] + generador.normal(scale=std, size=(n, n_caracteristica))) y += [i] * n X = np.concatenate(X) y = np.array(y) if shuffle: X, y = shuffle_(X, y, random_state=generador) return X, y
def make_blobs(n_samples=100, n_features=2, centers=2, cluster_std=1.0, center_box=(-10.0, 10.0), shuffle=True, random_state=None): """Generate isotropic Gaussian blobs for clustering. Read more in the :ref:`User Guide <sample_generators>`. Parameters ---------- n_samples : int, or tuple, optional (default=100) The total number of points equally divided among clusters. n_features : int, optional (default=2) The number of features for each sample. centers : int or array of shape [n_centers, n_features], optional (default=3) The number of centers to generate, or the fixed center locations. cluster_std: float or sequence of floats, optional (default=1.0) The standard deviation of the clusters. center_box: pair of floats (min, max), optional (default=(-10.0, 10.0)) The bounding box for each cluster center when centers are generated at random. shuffle : boolean, optional (default=True) Shuffle the samples. random_state : int, RandomState instance or None, optional (default=None) If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. Returns ------- X : array of shape [n_samples, n_features] The generated samples. y : array of shape [n_samples] The integer labels for cluster membership of each sample. Examples -------- >>> from sklearn.datasets.samples_generator import make_blobs >>> X, y = make_blobs(n_samples=10, centers=3, n_features=2, ... random_state=0) >>> print(X.shape) (10, 2) >>> y array([0, 0, 1, 0, 2, 2, 2, 1, 1, 0]) See also -------- make_classification: a more intricate variant """ generator = check_random_state(random_state) if isinstance(centers, numbers.Integral): centers = generator.uniform(center_box[0], center_box[1], size=(centers, n_features)) else: centers = check_array(centers) n_features = centers.shape[1] if isinstance(cluster_std, numbers.Real): cluster_std = np.ones(len(centers)) * cluster_std X = [] y = [] n_centers = centers.shape[0] if isinstance(n_samples, numbers.Integral): n_samples_per_center = [int(n_samples // n_centers)] * n_centers for i in range(n_samples % n_centers): n_samples_per_center[i] += 1 else: n_samples_per_center = n_samples for i, (n, std) in enumerate(zip(n_samples_per_center, cluster_std)): X.append(centers[i] + generator.normal(scale=std, size=(n, n_features))) y += [i] * n X = np.concatenate(X) y = np.array(y) if shuffle: X, y = shuffle_(X, y, random_state=generator) return X, y
def to_nparray(dir: str, size, channels_first=False, labels=None, shuffle=True, verbose=False): """Read an image dir and output all images into a numpy array with labels (optional) Parameters ---------- dir : str Image dir path. There must be no subfolder within, only images size : int 2-element tuple (height, width) channels_first : bool Decide whether the output array if of dims batch x channels x height x width (like pytorch) or batch x height x width x channels (like np) labels : None or dict if None, then no labels array is output, otherwise must be a dict of form {class_name: index, ...} shuffle : bool Decide whether shuffle data or not. Default True verbose : bool Decide whether logging or not Returns ------- np.array or tuple if labels not None, return a tuple of images array and labels list, otherwise return only the images array """ imgs = [] if labels is not None: assert isinstance(labels, dict), 'if not None, labels must be a dict' y = [] for fn in glob.glob(os.path.join(dir, '*')): if verbose: print('loading... {}'.format(os.path.basename(fn)), end='\r', flush=True) if labels is not None: for name in labels: if os.path.basename(fn).startswith(name): y.append(labels[name]) break im = Image.open(fn) im = im.resize(size) im = np.array(im) if channels_first: im = np.transpose(im, (2, 0, 1)) imgs.append(im) if verbose: print('\nDone.') X = np.stack(imgs, axis=0) if labels is not None: if shuffle: X, y = shuffle_(X, y) return X, y if shuffle: X = shuffle_(X) return X
def train(self, training_data, epochs, mini_batch_size, eta, validation_data, test_data=None, store_accuracies=False, shuffle = False, SGDR = False, save_dir=None, calibration=False, lmbda=0.0): '''Trains the neural network using Kingma and Ba's Adam algorithm (by default) Other optimization algorithms such as stochastic gradient descent can also be used. To do so, edit the (REQUIRED) training_data: training data in numpy array format (REQUIRED) epochs: number of training epochs (REQUIRED) mini_batch_size: size of mini batch for stochastic gradient descent (REQUIRED) eta: learning rate (Note: learning rate for GradientDescentOptimizer is ~100x larger than AdamOptimizer) (REQUIRED) validation_data: validation data in numpy array format test_data: test data in numpy array format store_accuracies: If True, stores the train, validation and test accuracies (Can be used for plotting against epoch for model calibration and hyperparameter tuning) NOTE: train and test accuracies will be stored only if calibration = True shuffle: Shuffle training dataset for training SGDR: Stochastic Gradient Descent with Restarts. See https://arxiv.org/abs/1608.03983 save_dir: Directory to store/load data. If None, stores data in default directory "/tmp/model.ckpt" calibration: If True, will calculate train and test accuracy for every epoch. NOTE: Should be disabled unless when calibrating as it will greatly slow down training. lmbda: Regularization parameter for l2 regularization :return: None ''' #Initialize accuracies list if store_accuracies: self.validation_accuracies = [] if calibration: self.train_accuracies = [] self.test_accuracies=[] #Compute number of minibatches for training, validation and testing num_training_batches = int(size(training_data)/mini_batch_size) num_validation_batches = int(size(validation_data)/mini_batch_size) if test_data: num_test_batches = int(size(test_data)/mini_batch_size) # define the (regularized) cost function l2_norm_squared = sum(tf.nn.l2_loss(layer.w) for layer in self.layers) cost = self.layers[-1].cost(self)+\ lmbda*l2_norm_squared/tf.cast(num_training_batches, dtype=tf.float32) #Create Global step global_step = tf.Variable(0, trainable=False, name='global_step') #global_step = tf.train.global_step(sess, global_step_tensor) #SGDR if SGDR: first_decay_steps = num_training_batches eta = tf.train.cosine_decay_restarts(eta, global_step, first_decay_steps) # Define optimizer with tf.name_scope('optimizer'): #train_step = tf.train.GradientDescentOptimizer(lr_decayed).minimize(cost) train_step = tf.train.AdamOptimizer(eta).minimize(cost) # Define minibatch accuracy operation ## Used to get train, validate and test accuracies in session mb_accuracy = self.layers[-1].accuracy(self.y) # Add ops to save and restore all the variables. saver = tf.train.Saver() #Loading of data training_x, training_y = training_data validation_x, validation_y = validation_data if test_data: test_x, test_y = test_data #~~~~~Do the actual training with tf.Session() as sess: #Initialize best accuracies best_validation_accuracy = 0 best_iteration = 0 test_accuracy = 0 if save_dir: try: print("\n\nSearching for stored model") saver.restore(sess, save_dir) print("Model restored.\n\n") except: print("No model of specified name found") print("Initializing new model...\n\n") sess.run(tf.global_variables_initializer()) else: print("\n\nInitializing new model...\n\n") sess.run(tf.global_variables_initializer()) start_time = time.time() #Track time taken for model try: for epoch in range(epochs): if shuffle == True: training_x, training_y = shuffle_(training_x, training_y) for minibatch_index in range(num_training_batches): iteration = num_training_batches*epoch+minibatch_index if iteration % 1000 == 0: print("Training mini-batch number {0}".format(iteration)) #Training of the model train_step.run(feed_dict={self.x: training_x[minibatch_index*self.mini_batch_size: (minibatch_index+1)*self.mini_batch_size], self.y: training_y[minibatch_index*self.mini_batch_size: (minibatch_index+1)*self.mini_batch_size]}) # Calculate and storing of Accuracies if (iteration+1) % num_training_batches == 0: if calibration: train_accuracy = np.mean( [mb_accuracy.eval(feed_dict={self.x: training_x[minibatch_index*self.mini_batch_size: (minibatch_index+1)*self.mini_batch_size], self.y: training_y[minibatch_index*self.mini_batch_size: (minibatch_index+1)*self.mini_batch_size]} ) for j in range(num_training_batches)]) print("Epoch {0}: train accuracy {1:.2%}".format( epoch, train_accuracy)) if store_accuracies: self.train_accuracies.append(train_accuracy) validation_accuracy = np.mean( [mb_accuracy.eval(feed_dict = {self.x: validation_x[j*self.mini_batch_size: (j+1)*self.mini_batch_size], self.y: validation_y[j*self.mini_batch_size: (j+1)*self.mini_batch_size] }) for j in range(num_validation_batches)]) print("Epoch {0}: validation accuracy {1:.2%}".format( epoch, validation_accuracy)) if store_accuracies: self.validation_accuracies.append(validation_accuracy) if calibration: if test_data: test_accuracy = np.mean( [mb_accuracy.eval(feed_dict = {self.x: test_x[j*self.mini_batch_size: (j+1)*self.mini_batch_size], self.y: test_y[j*self.mini_batch_size: (j+1)*self.mini_batch_size] }) for j in range(num_test_batches)]) print('The corresponding test accuracy is {0:.2%}'.format( test_accuracy)) if store_accuracies: self.test_accuracies.append(test_accuracy) if validation_accuracy >= best_validation_accuracy: print("This is the best validation accuracy to date.") best_validation_accuracy = validation_accuracy best_iteration = iteration if test_data: test_accuracy = np.mean( [mb_accuracy.eval(feed_dict = {self.x: test_x[j*self.mini_batch_size: (j+1)*self.mini_batch_size], self.y: test_y[j*self.mini_batch_size: (j+1)*self.mini_batch_size] }) for j in range(num_test_batches)]) print('The corresponding test accuracy is {0:.2%}'.format( test_accuracy)) #Saving best weights and biases #save_path = saver.save(sess, "/tmp/best.ckpt") #print("Best variables saved in specified file dir: %s" % save_path) if best_validation_accuracy == 1: raise GetOutOfLoop except GetOutOfLoop: print("100% Accuracy achieved. Stopping training...\n\n") pass end_time = time.time() total_time = end_time - start_time print("Finished training network.") print("Time to train network: {}s".format(total_time)) print("Number of examples trained per sec: {}".format(size(training_data)*epochs/total_time)) print("Best validation accuracy of {0:.2%} obtained at iteration {1}".format( best_validation_accuracy, str(best_iteration))) if test_data: print("Corresponding test accuracy of {0:.2%}".format(test_accuracy)) if save_dir: save_path = saver.save(sess, save_dir) print("Model saved in specified file dir: %s" % save_path) else: pass '''