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()
