def next_batch(num): (X_train, Y_train), (X_test, Y_test) = cifar10.load_data() # Center and stddev to 0 mean_img = np.mean(X_train, axis=0) stddev_img = np.std(X_train, axis=0) X_train = (X_train - mean_img) / stddev_img X_test = (X_test - mean_img) / stddev_img yield (X_test, Y_test) i = 0 indexes = np.arange(len(X_train)) indexes = np.random.choice(indexes, size=len(X_train)) X_train = X_train[indexes] Y_train = Y_train[indexes] while True: if i + num > len(X_train): i = 0 indexes = np.arange(len(X_train)) indexes = np.random.choice(indexes, size=len(X_train)) X_train = X_train[indexes] Y_train = Y_train[indexes] i += num yield (X_train[i - num:i], Y_train[i - num:i])
def Test_resnext(): m = resnext() (X, Y), (X_test, Y_test) = cifar10.load_data(dirname="/home/share/cnndata/", one_hot=True) params = { "loss": "square_loss", "metrics": ["loss"], "optimizer": "sgd", "learning_rate": 0.1, "batch_size": 256, "num_epochs": 30, "class_num": 10, "block_num": 5, "decay_steps": 32000, "decay_rate": 0.1, } feed_data = {"inputs": X, "labels": Y} test_feed_data = {"inputs": X_test, "labels": Y_test} m.set_parameter(params) time_start = time.time() m.train(feed_data, test_feed_data) time_end = time.time() time_delta = time_end - time_start print(time_delta / 1000) m.model_save("/home/share/model/res_next.ckpt") m.model_load("/home/share/model/res_next.ckpt") dic = m.evaluate(test_feed_data) print("Evaluate:" + str(dic))
def get_data(): # Data loading and preprocessing from tflearn.datasets import cifar10 (X, Y), (X_test, Y_test) = cifar10.load_data() X, Y = shuffle(X, Y) Y = to_categorical(Y, 10) Y_test = to_categorical(Y_test, 10) return (X, Y), (X_test, Y_test)
def TestGoogleV3(): m = GoogleNetV3(10) (X, Y), (X_test, Y_test) = cifar10.load_data(dirname="/home/share/cnndata/", one_hot=True) params = { "loss": "square_loss", "metrics": ["loss"], "optimizer": "sgd", "learning_rate": 1e-3, "batch_size": 32, "num_epochs": 1, } m.set_parameter(params) time_start = time.time() for max_step in range(0, 30000): index = np.random.choice(np.arange(len(X)), 32, replace=False) curbatchx = X[index] curbatchy = Y[index] curbatchx = GetCifar10Batch(299, 299, curbatchx) feed_data = {"inputs": curbatchx, "labels": curbatchy} acc = m.train_batch(feed_data) if (max_step % 300 == 0): print("step:" + str(max_step)) print("accuracy" + str(acc)) ''' for batchnumber in range(0,5): print("batch:\t"+str(batchnumber)) index = np.random.permutation(len(X)) xinput = X[index] Ycur = Y[index] xinput = xinput[0:10000] Ycur = Ycur[0:10000] #xinput = X[10000*batchnumber:10000*(batchnumber+1)] #Ycur = Y[10000*batchnumber:10000*(batchnumber+1)] Xcur= GetCifar10Batch(299, 299,xinput) print(len(Xcur)) print(len(Ycur)) ''' X_test = GetCifar10Batch(299, 299, X_test) test_feed_data = {"inputs": X_test, "labels": Y_test} time_end = time.time() time_delta = time_end - time_start print(time_delta / 1000) m.model_save("/home/share/model/GoogLeNetV3.ckpt") m.model_load("/home/share/model/GoogLeNetV3.ckpt") dic = m.evaluate(test_feed_data) print("Evaluate:" + str(dic))
def get_cifar10_data(validation_size=5000, one_hot=True): from tflearn.datasets import cifar10 (x_train, y_train), (x_test, y_test) = cifar10.load_data('temp-cifar10/data', one_hot=one_hot) x_val = x_train[:validation_size] y_val = y_train[:validation_size] x_train = x_train[validation_size:] y_train = y_train[validation_size:] return hype.Data(train=hype.DataSet(x_train, y_train), validation=hype.DataSet(x_val, y_val), test=hype.DataSet(x_test, y_test))
def prepare_data_cifar10(): ''' data preparation function :param X: 4d array, samples*H*W*channels, training data :param Y: 2d array, samples*num_class :param testX: 4d array, samples*H*W*channels, testing data :param testY: 2d array, samples*num_class ''' (X, Y), (testX, testY) = cifar10.load_data() num_class = len(Counter(Y)) Y = to_categorical(Y, num_class) testY = to_categorical(testY, num_class) return X, Y, testX, testY
def test(self): ops.reset_default_graph() (X, Y), (X_test, Y_test) = cifar10.load_data() X, Y = shuffle(X, Y) X = samplewise_zero_center(X) X = samplewise_stdnorm(X) X_test = samplewise_zero_center(X_test) X_test = samplewise_stdnorm(X_test) test_batch_data = tf.placeholder(name='data_pl', dtype=tf.float32, shape=(FLAGS.test_batch_size, ) + self.img_size) test_batch_labels = tf.placeholder(name='label_pl', dtype=tf.int32, shape=(FLAGS.test_batch_size, )) logits = getattr(Model, self.model)(test_batch_data) prediction = tf.cast(tf.argmax(logits, 1), tf.int32) correct_prediction = tf.equal(prediction, test_batch_labels) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) saver = tf.train.Saver(tf.global_variables()) sess = tf.Session(config=self.tf_config) saver.restore(sess, FLAGS.test_ckpt_path) print('Model restored from ', FLAGS.test_ckpt_path) prediction_array = np.array([]).reshape(-1, FLAGS.num_categories) num_batches = FLAGS.num_test_images // FLAGS.test_batch_size accuracy_list = [] for step in range(num_batches): batch_data, batch_labels = self._generate_batch( X_test, Y_test, FLAGS.test_batch_size, step, train=False) batch_prediction_array, batch_accuracy = sess.run( [prediction, accuracy], feed_dict={ test_batch_data: batch_data, test_batch_labels: test_batch_labels }) #prediction_array = np.concatenate((prediction_array, batch_prediction_array)) accuracy_list.append(batch_accuracy) accuracy = np.mean(np.array(accuracy_list, dtype=np.float32)) return prediction_array, accuracy_list
def tflearn_cifar(): """ 图像分类 :return: """ (X_train, Y_train), (X_test, Y_test) = cifar10.load_data() X_train, Y_train = shuffle(X_train, Y_train) Y_train = to_categorical(Y_train, nb_classes=10) Y_test = to_categorical(Y_test, nb_classes=10) # 对数据集进行零中心化(即对整个数据集计算平均值),同时进行 STD 标准化(即对整个数据集计算标准差) img_prep = ImagePreprocessing() img_prep.add_featurewise_zero_center() img_prep.add_featurewise_stdnorm() # 通过随机左右翻转和随机旋转来增强数据集 img_aug = ImageAugmentation() img_aug.add_random_flip_leftright() img_aug.add_random_rotation(max_angle=25.) # 定义模型 network = input_data(shape=(None, 32, 32, 3), data_preprocessing=img_prep, data_augmentation=img_aug) network = conv_2d(network, 32, 3, activation="relu") network = max_pool_2d(network, 2) network = conv_2d(network, 64, 3, activation="relu") network = conv_2d(network, 64, 3, activation="relu") network = max_pool_2d(network, 2) network = fully_connected(network, 512, activation="relu") network = dropout(network, 0.5) network = fully_connected(network, 10, activation="softmax") network = regression(network, optimizer="adam", loss="categorical_crossentropy", learning_rate=0.001) # 训练模型 model = DNN(network, tensorboard_verbose=0) model.fit(X_train, Y_train, n_epoch=50, shuffle=True, validation_set=(X_test, Y_test), show_metric=True, batch_size=96, run_id="cifar10_cnn")
def train(): # Data loading and preprocessing (X, Y), (X_test, Y_test) = cifar10.load_data() X, Y = shuffle(X, Y) Y = to_categorical(Y, 10) Y_test = to_categorical(Y_test, 10) # Train using classifier model = tflearn.DNN(initialise_model.create_network('adam'), tensorboard_verbose=0, checkpoint_path='cifar10.tfl.ckpt') #train the algorithm and take checkpoints every epoch model.fit(X, Y, n_epoch=50, shuffle=True, validation_set=(X_test, Y_test), snapshot_epoch=True, show_metric=True, batch_size=122, run_id='cifar10_cnn') #export the model model.save('cifar.tflearn')
def GetData(width, height): def getimage(X): result = [] for idx in range(0, len(X)): if idx % 10000 == 0: print("load data:\t" + str(idx) + "/" + str(len(inputx))) im = cv2.resize(X[idx], (width, height), interpolation=cv2.INTER_CUBIC) result.append(im) return result (X, Y), (X_test, Y_test) = cifar10.load_data(dirname="/home/share/cnndata/", one_hot=True) X = getimage(X) X_test = getimage(X_test) return X, Y, X_test, Y_test
def load_cifar10_dataset(data_dir=None): from tflearn.datasets import cifar10 from tflearn.data_utils import to_categorical HEIGHT = 32 WIDTH = 32 CHANNELS = 3 CLASSES = 10 (X, Y), (Xv, Yv) = cifar10.load_data(dirname=data_dir, one_hot=True) X, Y = shuffle(X, Y) Xv, Yv = shuffle(Xv, Yv) Xt = Xv[2000:] Yt = Yv[2000:] Xv = Xv[:2000] Yv = Yv[:2000] return CLASSES, X, Y, HEIGHT, WIDTH, CHANNELS, Xv, Yv, Xt, Yt
def get_data_CIFAR10(dataset = 'Train + Val'): from tflearn.datasets import cifar10 (X, Y), (X_test, Y_test) = cifar10.load_data() # Size is 32, 32, 3 split_percentage = 90 split_index = int(X.shape[0]/(100/split_percentage)) x_train = np.array(X[:split_index]) x_val = np.array(X[split_index:]) y_train = np.array(Y[:split_index]) y_val = np.array(Y[split_index:]) Y = to_categorical(Y, 10) Y_test = to_categorical(Y_test, 10) if dataset == 'Test': return x_train, x_val, y_train, y_val else: return X_test, Y_test
def Test_residual_bottleneck(): m = res_bottleneck() (X, Y), (X_test, Y_test) = cifar10.load_data(dirname="/home/share/cnndata/", one_hot=True) #X, Y, X_test, Y_test = mnist.load_data(one_hot=True) #X = X.reshape([-1, 28, 28, 1]) #X_test = X_test.reshape([-1, 28, 28, 1]) params = { "loss": "square_loss", "metrics": ["loss"], "optimizer": "sgd", "learning_rate": 1e-3, "batch_size": 128, "num_epochs": 200, "class_num": 10, "block_num": 5, "decay_steps": 100, "decay_rate": 0.96, } feed_data = {"inputs": X, "labels": Y} test_feed_data = {"inputs": X_test, "labels": Y_test} m.set_parameter(params) time_start = time.time() m.train(feed_data) time_end = time.time() time_delta = time_end - time_start print(time_delta / 1000) m.model_save("/home/share/model/res_bottleneck.ckpt") m.model_load("/home/share/model/res_bottleneck.ckpt") dic = m.evaluate(test_feed_data) print("Evaluate:" + str(dic))
Links: [CIFAR-10 Dataset](https://www.cs.toronto.edu/~kriz/cifar.html) """ from __future__ import division, print_function, absolute_import import tflearn from tflearn.data_utils import shuffle, to_categorical from tflearn.layers.core import input_data, dropout, fully_connected from tflearn.layers.conv import conv_2d, max_pool_2d from tflearn.layers.estimator import regression from tflearn.data_preprocessing import ImagePreprocessing from tflearn.data_augmentation import ImageAugmentation # Data loading and preprocessing from tflearn.datasets import cifar10 # 예제 데이터로 등록이 되어있구나 (X, Y), (X_test, Y_test) = cifar10.load_data() # 자동으로 다운받아지네 X, Y = shuffle(X, Y) # 섞는다 Y = to_categorical(Y, 10) Y_test = to_categorical(Y_test, 10) # Real-time data preprocessing img_prep = ImagePreprocessing() img_prep.add_featurewise_zero_center() img_prep.add_featurewise_stdnorm() # Real-time data augmentation img_aug = ImageAugmentation() img_aug.add_random_flip_leftright() img_aug.add_random_rotation(max_angle=25.) # Convolutional network building
system that uses directed acyclic graphs (DAGs) of tasks to break up large computations into many small ones. It can handle large dataset that could not fit totally in ram memory. Note that this example just give a quick compatibility demonstration. In practice, there is no so much need to use Dask for small dataset such as CIFAR-10. """ import tflearn from tflearn.layers.core import * from tflearn.layers.conv import * from tflearn.data_utils import * from tflearn.layers.estimator import regression # load CIFAR-10 Dataset from tflearn.datasets import cifar10 (X, Y), (test_X, test_Y) = cifar10.load_data() Y = to_categorical(Y) test_Y - to_categorical(test_Y) # create DASK array using numpy arrays import dask.array as da X = da.from_array(np.asarray(X), chunks=(1000, 1000, 1000, 1000)) Y = da.from_array(np.asarray(Y), chunks=(1000, 1000, 1000, 1000)) test_X = da.from_array(np.asarray(test_X), chunks=(1000, 1000, 1000, 1000)) test_X = da.from_array(np.asarray(test_Y), chunks=(1000, 1000, 1000, 1000)) # Build network network = input_data(shape=[None, 32, 32, 3]) network = conv_2d(network, 32, 3, activation='relu') network = max_pool_2d(network, 2)
# Challenge : CIFAR-10 dataset import os os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # Parameters learning_rate = 0.01 training_epochs = 1 batch_size = 100 import tensorflow as tf from tflearn.datasets import cifar10 from tflearn.data_utils import to_categorical (X_train, Y_train), (X_test, Y_test) = cifar10.load_data() Y_train = to_categorical(Y_train, 10) Y_test = to_categorical(Y_test, 10) # Step 1: Initial Setup X = tf.placeholder(tf.float32, [None, 32, 32, 3]) y = tf.placeholder(tf.float32, [None, 10]) pkeep = tf.placeholder(tf.float32) # three convolutional layers with their channel counts, and a # fully connected layer (tha last layer has 10 softmax neurons) L1 = 32 # first convolutional layer output depth L2 = 64 # second convolutional layer output depth L3 = 1024 # Fully connected layer W1 = tf.Variable(tf.truncated_normal([5, 5, 3, L1], stddev=0.1))
import tflearn from tflearn.layers.core import * from tflearn.layers.conv import * from tflearn.data_utils import * from tflearn.layers.normalization import * from tflearn.layers.estimator import regression # CIFAR-10 Dataset from tflearn.datasets import cifar10 (X, Y), (X_test, Y_test) = cifar10.load_data(dirname='./data/cifar-10-batches-py') Y = to_categorical(Y, 10) Y_test = to_categorical(Y_test, 10) def data_manager_h5py(): # create a hdf5 dataset from CIFAT-10 numpy array import h5py h5f = h5py.File('data.h5', 'w') h5f.create_dataset('cifar10_X', data=X) h5f.create_dataset('cifar10_Y', data=Y) h5f.create_dataset('cifar10_X_test', data=X_test) h5f.create_dataset('cifar10_Y_test', data=Y_test) h5f.close() h5f = h5py.File('data.h5', 'r') X = h5f['cifar10_X'] Y = h5f['cifar10_Y'] X_test = h5f['cifar10_X_test'] Y_test = h5f['cifar10_Y_test'] # build network network = input_data(shape=[None, 32, 32, 3], dtype=tf.float32) network = conv_2d(network, 32, 3, activation='relu')
import tflearn from tflearn.data_utils import shuffle, to_categorical from tflearn.layers.core import input_data, dropout, fully_connected from tflearn.layers.conv import conv_2d, max_pool_2d from tflearn.layers.estimator import regression from tflearn.data_preprocessing import ImagePreprocessing from tflearn.data_augmentation import ImageAugmentation import scipy import sys from sklearn.cluster import KMeans import tensorflow as tf import numpy as np # Data loading and preprocessing from tflearn.datasets import cifar10 (X, Y), (X_test, Y_test) = cifar10.load_data(dirname="..") X, Y = shuffle(X, Y) Y = to_categorical(Y, 10) Y_test = to_categorical(Y_test, 10) # Real-time data preprocessing img_prep = ImagePreprocessing() img_prep.add_featurewise_zero_center() img_prep.add_featurewise_stdnorm() # Real-time data augmentation img_aug = ImageAugmentation() img_aug.add_random_flip_leftright() img_aug.add_random_rotation(max_angle=25.) '''----------------add kmeans here----------------------------'''
from __future__ import division, print_function, absolute_import import numpy as np import matplotlib.pyplot as plt import tflearn from tflearn.data_utils import shuffle # Data loading and preprocessing from tflearn.datasets import cifar10 (X, Y), (X_test, Y_test) = cifar10.load_data(one_hot = True, flat = True) X, Y = shuffle(X, Y) # Building the encoder encoder = tflearn.input_data(shape=[None, 32*32*3]) encoder = tflearn.fully_connected(encoder, 512) encoder = tflearn.fully_connected(encoder, 512) encoder = tflearn.fully_connected(encoder, 512) encoder = tflearn.fully_connected(encoder, 64, activation='tanh') # Binarize layer binary = encoder # Building the decoder decoder = tflearn.fully_connected(binary, 512) decoder = tflearn.fully_connected(decoder, 512) decoder = tflearn.fully_connected(decoder, 512) decoder = tflearn.fully_connected(decoder, 32*32*3) # Regression, with mean square error net = tflearn.regression(decoder, optimizer='adam', learning_rate=0.001,
# save layers for cvs model data layers = [] layers.append(inputlayer) for i in range(innerLayers): layers.append(jdata.layers[i].nodes) layers.append(outputlayer) if jdata.model == "mnist": # input 784 - output 10 print("http://yann.lecun.com/exdb/mnist/") import tflearn.datasets.mnist as mnist X, Y, testX, testY = mnist.load_data(one_hot=True) elif jdata.model == "cifar10": # input 1024 - output 10 print("https://www.cs.toronto.edu/~kriz/cifar.html") from tflearn.datasets import cifar10 (X, Y), (testX, testY) = cifar10.load_data() X, Y = shuffle(X, Y) Y = to_categorical(Y) testY = to_categorical(testY) X = shapeToOneD(X) Y = shapeToOneD(Y) testX = shapeToOneD(testX) testY = shapeToOneD(testY) elif jdata.model == "cifar100": # input 1024 - output 100 print("https://www.cs.toronto.edu/~kriz/cifar.html") from tflearn.datasets import cifar100 (X, Y), (testX, testY) = cifar100.load_data() elif jdata.model == "oxflower17.py": # input 50176 - output 17 print("http://www.robots.ox.ac.uk/~vgg/data/flowers/17/") from tflearn.datasets import oxflower17 (X, Y) = oxflower17.load_data()
system that uses directed acyclic graphs (DAGs) of tasks to break up large computations into many small ones. It can handle large dataset that could not fit totally in raw memory. """ from __future__ import division, print_function, absolute_import import tflearn from tflearn.layers.core import * from tflearn.layers.conv import * from tflearn.data_utils import * from tflearn.layers.estimator import * # CIFAR-10 Dataset from tflearn.datasets import cifar10 (X, Y), (X_test, Y_test) = cifar10.load_data() Y = to_categorical(Y, 10) Y_test = to_categorical(Y_test, 10) # Create DASK array using numpy arrays # (Note that it can work with HDF5 Dataset too) import dask.array as da X = da.from_array(np.asarray(X), chunks=(1000, 1000, 1000, 1000)) Y = da.from_array(np.asarray(Y), chunks=(1000, 1000, 1000, 1000)) X_test = da.from_array(np.asarray(X_test), chunks=(1000, 1000, 1000, 1000)) Y_test = da.from_array(np.asarray(Y_test), chunks=(1000, 1000, 1000, 1000)) # Build network network = input_data(shape=[None, 32, 32, 3], dtype=tf.float32) network = conv_2d(network, 32, 3, activation='relu')
just give a quick compatibility demonstration. In practice, there is no so real need to use HDF5 for small dataset such as CIFAR-10. """ from __future__ import division, print_function, absolute_import import tflearn from tflearn.layers.core import * from tflearn.layers.conv import * from tflearn.data_utils import * from tflearn.layers.normalization import * from tflearn.layers.estimator import regression # CIFAR-10 Dataset from tflearn.datasets import cifar10 (X, Y), (X_test, Y_test) = cifar10.load_data() Y = to_categorical(Y) Y_test = to_categorical(Y_test) # Create a hdf5 dataset from CIFAR-10 numpy array import h5py h5f = h5py.File('data.h5', 'w') h5f.create_dataset('cifar10_X', data=X) h5f.create_dataset('cifar10_Y', data=Y) h5f.create_dataset('cifar10_X_test', data=X_test) h5f.create_dataset('cifar10_Y_test', data=Y_test) h5f.close() # Load hdf5 dataset h5f = h5py.File('data.h5', 'r') X = h5f['cifar10_X']
else: ax[i, j].imshow(np.reshape(pca_samples[k], (32, 32, 3))) label = 'Principle Component {0}'.format(num_pcs) fig.text(0.5, 0.004, label, ha='center') plt.show() plt.savefig(path) # load MNIST dset = 'CIFAR' if dset == 'MNIST': mnist = fetch_mldata('MNIST original') train_set = mnist.data[:].astype(np.float32) if dset == 'CIFAR': (train_set, Y), _ = cifar10.load_data() train_set, Y = shuffle(train_set, Y) train_set = np.reshape(train_set, (-1, 32 * 32 * 3)) # Mix 'er up np.random.shuffle(train_set) # Normalize 0,1 # train_set = (train_set-np.min(train_set))/(np.max(train_set)-np.min(train_set)) # train_set = mnist.train.images # train_set = (train_set - 0.5) / 0.5 # normalization; range: -1 ~ 1 # train_set = (train_set - np.mean(train_set)) / np.std(train_set) # Samples to reconstruct in pca visualization fixed_sample_batch = train_set[:25] # Fit PCA on MNIST
from __future__ import division, print_function, absolute_import import tflearn from tflearn.layers.core import * from tflearn.layers.conv import * from tflearn.layers.estimator import * from tflearn.data_utils import * # Load Cifar10 DataSet from tflearn.datasets import cifar10 (X, Y), (X_test, Y_test) = cifar10.load_data("/dataset") Y = to_categorical(Y, 10) Y_test = to_categorical(Y_test, 10) print(X.shape) print(Y.shape) print(X_test.shape) print(Y_test.shape) # # Create DASK array using numpy arrays # import dask.array as da # X = da.from_array(np.asarray(X), chunks=(1000)) # Y = da.from_array(np.asarray(Y), chunks=(1000)) # # X_test = da.from_array(np.asarray(X_test), chunks=(1000)) # Y_test = da.from_array(np.asarray(Y_test), chunks=(1000)) # # Create a hdf5 dataset from CIFAR-10 numpy array import h5py h5f = h5py.File('data.h5', 'w') h5f.create_dataset('cifar10_X', data=X) h5f.create_dataset('cifar10_Y', data=Y)
import tflearn from tflearn.layers.conv import conv_2d,max_pool_2d from tflearn.layers.core import input_data,dropout,fully_connected from tflearn.layers.estimator import regression import tflearn.datasets.cifar10 as cifar import numpy as np (X,Y),(test_x,test_y)=cifar.load_data(one_hot=True) #X=np.array(X) #test_x=np.array(test_x) #test_y=np.array(test_y) #Y=np.array(Y) X=X.reshape([-1,32,32,3]) test_x=test_x.reshape([-1,32,32,3]) convnet=input_data(shape=[None,32,32,3],name='input') convnet=conv_2d(convnet,32,3,activation='relu') convnet=max_pool_2d(convnet,2) convnet=conv_2d(convnet,64,3,activation='relu') convnet=max_pool_2d(convnet,2) convnet=conv_2d(convnet,128,3,activation='relu') convnet=conv_2d(convnet,128,3,activation='relu') convnet=max_pool_2d(convnet,2) convnet=fully_connected(convnet,512,activation='relu') convnet=fully_connected(convnet,512,activation='relu') convnet=dropout(convnet,0.8)
""" from __future__ import division, print_function, absolute_import import tflearn # Residual blocks # 32 layers: n=5, 56 layers: n=9, 110 layers: n=18 n = 5 datapath = '../../data/cifar-10-batches-py' # Data loading from tflearn.datasets import cifar10 (X, Y), (testX, testY) = cifar10.load_data(dirname=datapath) Y = tflearn.data_utils.to_categorical(Y, 10) testY = tflearn.data_utils.to_categorical(testY, 10) # Real-time data preprocessing img_prep = tflearn.ImagePreprocessing() img_prep.add_featurewise_zero_center(per_channel=True) # Real-time data augmentation img_aug = tflearn.ImageAugmentation() img_aug.add_random_flip_leftright() img_aug.add_random_crop([32, 32], padding=4) # Building Residual Network net = tflearn.input_data(shape=[None, 32, 32, 3], data_preprocessing=img_prep,
#for deep learning course in NCTU 2017 #if you have questions, mail to [email protected] #the code demonstrate the NIN arch on MNIST #It achieved 0.41% test error (the original paper reported 0.47% test error) from __future__ import print_function import tensorflow as tf from tflearn.datasets import cifar10 import numpy as np import csv DATA_SIZE = 0 BATCH_SIZE = 128 (X, Y), (X_test, Y_test) = cifar10.load_data(one_hot=True) DATA_SIZE = len(X) # define functions def weight_variable(shape): initial = tf.random_normal(shape, stddev=0.05, dtype=tf.float32) return tf.Variable(initial) def bias_variable(shape): initial = tf.constant(0, shape=shape, dtype=tf.float32) return tf.Variable(initial) def conv2d(x, W): return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
import sys import os os.environ["CUDA_VISIBLE_DEVICES"] = '1' import numpy as np np.set_printoptions(precision=4, suppress=True, linewidth=100) import re import tensorflow as tf import tensorflow.contrib.layers as cl from model import trash_cnn_cifar # Data loading and preprocessing import tflearn from tflearn.data_utils import shuffle, to_categorical from tflearn.datasets import cifar10 (cifar10_X, cifar10_Y), (X_test, Y_test) = cifar10.load_data() cifar10_X = np.transpose(cifar10_X, [0, 3, 1, 2]) cifar10_Y = to_categorical(cifar10_Y, 10) X_test = np.transpose(X_test, [0, 3, 1, 2]) Y_test = to_categorical(Y_test, 10) cnn = trash_cnn_cifar(name='aaaa') # cnn = resnet('resnet', 5, grid=True) WEIGHT_DECAY = 1e-4 l2 = cl.l2_regularizer(WEIGHT_DECAY) batch_size = 100 import logging logging.basicConfig( filename='textlogB.log', filemode='a',
import tflearn from tflearn.data_utils import shuffle, to_categorical from tflearn.layers.core import input_data, dropout, fully_connected from tflearn.layers.conv import conv_2d, max_pool_2d from tflearn.layers.estimator import regression from tflearn.data_preprocessing import ImagePreprocessing from tflearn.data_augmentation import ImageAugmentation # Data loading and preprocessing from tflearn.datasets import cifar10 SOURCE='/Users/leidelong/data/' (X, Y), (X_test, Y_test) = cifar10.load_data(SOURCE+'cifar10/cifar-10-batches-py') X, Y = shuffle(X, Y) Y = to_categorical(Y, 10) Y_test = to_categorical(Y_test, 10) # Real-time data preprocessing img_prep = ImagePreprocessing() img_prep.add_featurewise_zero_center() img_prep.add_featurewise_stdnorm() # Real-time data augmentation img_aug = ImageAugmentation() img_aug.add_random_flip_leftright() img_aug.add_random_rotation(max_angle=25.) # Convolutional network building
# cluster = tf.train.ClusterSpec({"ps": ["localhost:2222"], # "worker": ["localhost:2223", "localhost:2224"]}) '''Setting up the cluster for workers and the one parameter server. ''' cluster = tf.train.ClusterSpec({ "ps": ["mist31-umh.cs.umn.edu:2227"], "worker": ["mist31-umh.cs.umn.edu:2229"] }) server = tf.train.Server(cluster, job_name=job_name, task_index=task_number) print("Starting server /job:{}/task:{}".format(job_name, task_number)) print("Starting server /job:{}/task:{}".format(job_name, task_number)) # Data loading (x_image, Y), (X_test, Y_test) = cifar10.load_data() y_test_vector = to_categorical(Y_test, 10) y_vector = to_categorical(Y, 10) y_features = to_categorical(np.arange(10), 10) print("Image data: cifar10.load_data (50000)") ''' I am comfortable enough to be able to recreate AlexNet following the paper, however, I am still uncertain about how to go about it with Cifar Dataset ''' if job_name == "ps": server.join() elif job_name == "worker":
import tflearn import numpy as np import tarfile from tflearn.datasets import cifar10 from tflearn.data_utils import shuffle from tflearn.data_preprocessing import ImagePreprocessing from tflearn.data_augmentation import ImageAugmentation from tflearn.layers.core import input_data, dropout,fully_connected from tflearn.layers.conv import conv_2d,max_pool_2d from tflearn.layers.estimator import regression #load data (X_train,Y_train),(X_test,Y_test) = cifar10.load_data(dirname="./data/cifar10/cifar-10-batches-py", one_hot=True) X_train,Y_train = shuffle(X_train,Y_train) #data preprocessing img_prep = ImagePreprocessing() img_prep.add_featurewise_zero_center() img_prep.add_featurewise_stdnorm() img_aug = ImageAugmentation() img_aug.add_random_rotation(max_angle=25.) img_aug.add_random_flip_leftright() #build neural net net = input_data(shape=[None,32,32,3],data_preprocessing=img_prep, data_augmentation=img_aug) #layer 1 net = conv_2d(net,32,3,activation='relu') net = max_pool_2d(net,2)
from tflearn.layers.normalization import local_response_normalization import matplotlib.pyplot as plt from sklearn.metrics import roc_auc_score from sklearn.metrics import precision_score # Global variables nb_feature = 64 image_and_anamolies = {'image': 5,'anomalies1':3,'anomalies2':3,'imagecount': 5000,'anomaliesCount':50} image_with_noise_injection = {'image': 5,'imagecount': 5000} ROOT = "/Users/raghav/Documents/Uni/KDD-2017/sample_autoencoder/autoencode_softthreshold/cifar-10-batches-py" basepath="/Users/raghav/Documents/Uni/ECML_2017/experiments/cifar_10/cae/results/inductive/" mean_square_error_dict ={} # load cifar-10 data (X, Y), (testX, testY) = cifar10.load_data(ROOT) testX = np.asarray(testX) testY = np.asarray(testY) side = X.shape[1] channel = X.shape[3] noise_factor = 0.1 print side print channel # Define the convoluted ae architecture def encoder(inputs,hidden_layer): net = tflearn.conv_2d(inputs, 16, 3, strides=2) net = tflearn.batch_normalization(net)
def train(self, **kwargs): ops.reset_default_graph() sess = tf.Session(config=self.tf_config) with sess.as_default(): (X, Y), (X_test, Y_test) = cifar10.load_data() X, Y = shuffle(X, Y) X = samplewise_zero_center(X) X = samplewise_stdnorm(X) X_test = samplewise_zero_center(X_test) X_test = samplewise_stdnorm(X_test) Y = to_categorical(Y, 10) Y_test = to_categorical(Y_test, 10) self.train_data, self.train_label = np.array( X, dtype=np.float32), np.array(Y, dtype=np.int32) self.vali_data, self.vali_label = np.array( X_test, dtype=np.float32), np.array(Y_test, dtype=np.int32) print(len(self.train_data)) # Data Reading objects self._placeholders() if len(kwargs) == 0: self.dict_widx = None self._build_graph() self.saver = tf.train.Saver(tf.global_variables()) # Build an initialization operation to run below init = tf.global_variables_initializer() sess.run(init) else: self.dict_widx = kwargs['dict_widx'] pruned_model = kwargs['pruned_model_path'] tflearn.config.init_training_mode() self._build_graph() init = tf.global_variables_initializer() sess.run(init) self.saver = tf.train.Saver(tf.global_variables()) self.saver.restore(sess, pruned_model) print('Pruned model restored from ', pruned_model) # This summary writer object helps write summaries on tensorboard summary_writer = tf.summary.FileWriter(FLAGS.log_dir + self.run_id) summary_writer.add_graph(sess.graph) train_error_list = [] val_error_list = [] print('Start training...') print('----------------------------------') train_steps_per_epoch = FLAGS.num_train_images // FLAGS.train_batch_size report_freq = train_steps_per_epoch train_steps = FLAGS.train_epoch * train_steps_per_epoch durations = [] train_loss_list = [] train_accuracy_list = [] train_total_loss_list = [] best_accuracy = 0 log_file = open( os.path.join(FLAGS.log_dir, self.run_id, 'loss_accuracy_list'), 'a') for step in range(train_steps): tflearn.is_training(True) start_time = time.time() train_batch_data, train_batch_labels = self._generate_batch( self.train_data, self.train_label, FLAGS.train_batch_size, step, train=True) _, summary_str, loss_value, total_loss, accuracy = sess.run( [ self.train_op, self.summary_op, self.loss, self.total_loss, self.accuracy ], feed_dict={ self.batch_data: train_batch_data, self.batch_labels: train_batch_labels }) #summary_str = '' duration = time.time() - start_time durations.append(duration) #print(duration) train_loss_list.append(loss_value) train_total_loss_list.append(total_loss) train_accuracy_list.append(accuracy) assert not np.isnan( loss_value), 'Model diverged with loss = NaN' if step % report_freq == 0: summary_writer.add_summary(summary_str, step) sec_per_report = np.sum(np.array(durations)) * 1.2 train_loss_value = np.mean(np.array(train_loss_list)) train_total_loss = np.mean(np.array(train_total_loss_list)) train_accuracy_value = np.mean( np.array(train_accuracy_list)) train_loss_list = [] train_total_loss_list = [] train_accuracy_list = [] durations = [] train_summ = tf.Summary() train_summ.value.add(tag="train_loss", simple_value=train_loss_value.astype( np.float)) train_summ.value.add(tag="train_total_loss", simple_value=train_total_loss.astype( np.float)) train_summ.value.add( tag="train_accuracy", simple_value=train_accuracy_value.astype(np.float)) summary_writer.add_summary(train_summ, step) vali_loss_value, vali_accuracy_value = self._full_validation( sess) if vali_accuracy_value > best_accuracy: best_accuracy = vali_accuracy_value model_dir = os.path.join(FLAGS.log_dir, self.run_id, 'model') if not os.path.isdir(model_dir): os.mkdir(model_dir) checkpoint_path = os.path.join( model_dir, 'vali_{:.3f}'.format(vali_accuracy_value)) self.saver.save(sess, checkpoint_path, global_step=step) vali_summ = tf.Summary() vali_summ.value.add(tag="vali_loss", simple_value=vali_loss_value.astype( np.float)) vali_summ.value.add( tag="vali_accuracy", simple_value=vali_accuracy_value.astype(np.float)) summary_writer.add_summary(vali_summ, step) summary_writer.flush() format_str = ( 'Epoch %d, loss = %.4f, total_loss = %.4f, accuracy = %.4f, vali_loss = %.4f, vali_accuracy = %.4f (%.3f ' 'sec/report)') print( format_str % (step // report_freq, train_loss_value, train_total_loss, train_accuracy_value, vali_loss_value, vali_accuracy_value, sec_per_report)) log_file.write('{},{},{},{} \n'.format( train_loss_value, train_accuracy_value, vali_loss_value, vali_accuracy_value)) log_file.close()