def get_data():
y_train = read_all_images('./data/stl10_binary/train_X.bin')
y_test = read_all_images('./data/stl10_binary/test_X.bin')
x_train = np.load(os.path.join('./data/', train_filename),
allow_pickle=True)
x_test = np.load(os.path.join('./data/', test_filename), allow_pickle=True)
return (x_train, y_train), (x_test, y_test)
def load_labeld_data(grayscale = False):
"""
The value of labels should start from 0
Do we need to normalize the data to be between 0-1? no need currently, otherwise double value needs more memory
Grayscale the images
:return:
"""
train_inputs = stl10_input.read_all_images(train_X_path)
train_labels = stl10_input.read_labels(train_y_path)
test_inputs = stl10_input.read_all_images(test_X_path)
test_labels = stl10_input.read_labels(test_y_path)
if grayscale:
return grayScaler(train_inputs)/255.0, train_labels - 1, grayScaler(test_inputs)/255.0, test_labels - 1
else:
return train_inputs/255.0, train_labels - 1, test_inputs/255.0, test_labels - 1
def load_stl10_data():
"""
a functio to load stl_10 binary dataset
the dataset save in ```stl10_binary``` folder
"""
x = read_all_images('stl10_binary/train_X.bin')
y = read_labels('stl10_binary/train_y.bin')
y = y - 1
y = keras.utils.to_categorical(y, num_classes=10)
val_x = read_all_images('stl10_binary/test_X.bin')
val_y = read_labels('stl10_binary/test_y.bin')
val_y = val_y - 1
val_y = keras.utils.to_categorical(val_y, 10)
return (x, y), (val_x, val_y)
def load_labeld_data(grayscale=False):
"""
The value of labels should start from 0
Do we need to normalize the data to be between 0-1? no need currently, otherwise double value needs more memory
Grayscale the images
:return:
"""
train_inputs = stl10_input.read_all_images(train_X_path)
train_labels = stl10_input.read_labels(train_y_path)
test_inputs = stl10_input.read_all_images(test_X_path)
test_labels = stl10_input.read_labels(test_y_path)
if grayscale:
return grayScaler(train_inputs) / 255.0, train_labels - 1, grayScaler(
test_inputs) / 255.0, test_labels - 1
else:
return train_inputs / 255.0, train_labels - 1, test_inputs / 255.0, test_labels - 1
def __init__(self):
# Replace "train" with "test" or "unlabeled"
train_re = re.compile(r"train_")
train_to_test = lambda x: train_re.sub("test_", x)
current_dir = os.getcwd()
os.chdir(os.path.join("STL10"))
stl10_input.download_and_extract()
# Populate the training set
self.x_train = stl10_input.read_all_images(stl10_input.DATA_PATH)
self.y_train = stl10_input.read_labels(stl10_input.LABEL_PATH)
self.y_train -= 1 # Labels are not 0-indexed
self.x_test = stl10_input.read_all_images(
train_to_test(stl10_input.DATA_PATH))
self.y_test = stl10_input.read_labels(
train_to_test(stl10_input.LABEL_PATH))
self.y_test -= 1 # Labels are not 0-indexed
#self.x_unlabeled = stl10_input.read_all_images(train_to_unlabeled(stl10_input.DATA_PATH))
os.chdir(current_dir)
def prepare_data():
# Download and Organize data
stl.download_and_extract()
images = stl.read_all_images(DATA_PATH)
labels = stl.read_labels(LABEL_PATH)
test_x = stl.read_all_images(TEST_DATA_PATH)
test_y = stl.read_labels(TEST_LABEL_PATH)
train_x = images[:NUM_TRAINING_SAMPLES]
train_y = labels[:NUM_TRAINING_SAMPLES]
val_x = images[-NUM_VAL_SAMPLES:]
val_y = labels[-NUM_VAL_SAMPLES:]
if not os.path.isdir(TRAIN_DIR):
os.makedirs(TRAIN_DIR)
if not os.path.isdir(VAL_DIR):
os.makedirs(VAL_DIR)
if not os.path.isdir(TRAIN_DIR):
os.makedirs(TRAIN_DIR)
stl.save_images(train_x, train_y, TRAIN_DIR)
stl.save_images(val_x, val_y, VAL_DIR)
stl.save_images(test_x, test_y, TEST_DIR)
def train():
#
fileName = "..\\data\\train_X.bin"
X_train = read_all_images(fileName)
testFile = "..\\data\\test_X.bin"
X_test = read_all_images(testFile)
test_y_File = "..\\data\\test_y.bin"
targets = read_labels(test_y_File)
# mnist = fetch_openml('mnist_784', version=1, cache=True)
# targets = mnist.target[60000:]
#
# X_train = mnist.data[:60000]
# X_test = mnist.data[60000:]
script_directory = os.path.split(os.path.abspath(__file__))[0]
colons = []
optimizers = []
colons_paths = []
filepath = 'encoders\\encoder_' + str(0) + '.model'
predictor_model = os.path.join(script_directory, filepath)
colons_paths.append(predictor_model)
c = CapsNet()
c = c.cuda()
colons.append(c)
optimizer = torch.optim.Adam(c.parameters(), lr=LEARNING_RATE_DEFAULT)
optimizers.append(optimizer)
max_loss = 10000000
for iteration in range(MAX_STEPS_DEFAULT):
ids = np.random.choice(len(X_train),
size=BATCH_SIZE_DEFAULT,
replace=False)
train = True
products, mim, new_preds = forward_block(X_train, ids, colons,
optimizers, train,
BATCH_SIZE_DEFAULT)
if iteration % EVAL_FREQ_DEFAULT == 0:
# print_dict = {"0": "", "1": "", "2": "", "3": "", "4": "", "5": "", "6": "", "7": "", "8": "", "9": ""}
print_dict = {
1: "",
2: "",
3: "",
4: "",
5: "",
6: "",
7: "",
8: "",
9: "",
0: ""
}
test_ids = np.random.choice(len(X_test),
size=BATCH_SIZE_DEFAULT,
replace=False)
products, mim, new_preds = forward_block(X_test, test_ids, colons,
optimizers, False,
BATCH_SIZE_DEFAULT)
# test_ids = np.random.choice(len(X_test), size=BATCH_SIZE_DEFAULT, replace=False)
# products, mim = forward_block(X_test, test_ids, colons, optimizers, False, BATCH_SIZE_DEFAULT)
# print_dict = gather_data(print_dict, products, targets, test_ids)
#
# test_ids = np.random.choice(len(X_test), size=BATCH_SIZE_DEFAULT, replace=False)
# products, mim = forward_block(X_test, test_ids, colons, optimizers, False, BATCH_SIZE_DEFAULT)
# print_dict = gather_data(print_dict, products, targets, test_ids)
# print("loss 1: ", mim.item())
# products, mim = forward_block(X_test, test_ids, colons, optimizers, False, BATCH_SIZE_DEFAULT)
print()
print("iteration: ", iteration)
print_dict = gather_data(print_dict, new_preds, targets, test_ids)
print_info(print_dict)
test_loss = mim.item()
if max_loss > test_loss:
max_loss = test_loss
print("models saved iter: " + str(iteration))
# for i in range(number_colons):
# torch.save(colons[i], colons_paths[i])
print("test loss " + str(test_loss))
print("")
import numpy as np
import tqdm
from skimage.io import imread
from skimage.transform import resize
import matplotlib.pyplot as plt
import stl10_input as STL10
#STL-10
DATA_PATH = './train_X.bin'
LABEL_PATH = './train_y.bin'
x_inp = STL10.read_all_images(DATA_PATH)
label = STL10.read_labels(LABEL_PATH)
x_processed = np.load('./processed_train_X.npy')
for index, img in tqdm.tqdm(enumerate(x_inp)):
test_img = resize(img,(229,229), mode = 'constant')
processed_vector = x_processed[index]
plt.imshow(test_img)
plt.show()
tmp = Y[i:i + 1].copy()
Y[i] = Y[j]
Y[j] = tmp
TrainX = np.zeros((24000, 96, 96, 3), dtype=np.uint8)
TrainY = np.zeros((24000, 1), dtype=np.uint8)
s = 0
TrainX[s:s + 12000] = np.array(
load_zipped_pickle('UECTrainInstance.gz')).astype(dtype=np.uint8)
TrainY[s:s + 12000] = np.ones([12000, 1])
s += 12000
TrainX[s:s + 5000] = np.array(
stl10_input.read_all_images('stl10_binary/train_X.bin')[:5000]).astype(
dtype=np.uint8)
TrainY[s:s + 5000] = np.zeros([5000, 1])
s += 5000
TrainX[s:s + 7000] = np.array(
load_zipped_pickle('MITTrainInstance.gz')).astype(dtype=np.uint8)
TrainY[s:s + 7000] = np.zeros([7000, 1])
shuffle(TrainX, TrainY)
TrainX.tofile('train_images.bin')
TrainY.tofile('train_labels.bin')
TestX = np.zeros((4000, 96, 96, 3), dtype=np.uint8)
TestY = np.zeros((4000, 1), dtype=np.uint8)
for i in range(dataset.shape[0]):
watermarked_imgs[i] = add_watermark(dataset[i])
stdout.write("\rWriting watermark dataset. {0:5.2f}% done.".format(
i / dataset.shape[0] * 100))
stdout.flush()
print(" Done writing.")
write_to_file(filename, watermarked_imgs)
def write_to_file(filename, dataset):
np.save(os.path.join('./data/', filename), dataset)
def get_data():
y_train = read_all_images('./data/stl10_binary/train_X.bin')
y_test = read_all_images('./data/stl10_binary/test_X.bin')
x_train = np.load(os.path.join('./data/', train_filename),
allow_pickle=True)
x_test = np.load(os.path.join('./data/', test_filename), allow_pickle=True)
return (x_train, y_train), (x_test, y_test)
if __name__ == "__main__":
download_and_extract()
y_train = read_all_images('./data/stl10_binary/train_X.bin')
y_test = read_all_images('./data/stl10_binary/test_X.bin')
write_watermark_dataset(y_train, train_filename)
write_watermark_dataset(y_test, test_filename)
#################################################################################
# Read Dataset
#################################################################################
# dataset paths
path_dataset = 'D:\\ANN\\dataset\\stl10_binary\\stl10_binary'
path_train_x = 'D:\\ANN\\dataset\\stl10_binary\\stl10_binary\\train_X.bin'
path_train_y = 'D:\\ANN\\dataset\\stl10_binary\\stl10_binary\\train_y.bin'
path_test_x = 'D:\\ANN\\dataset\\stl10_binary\\stl10_binary\\test_X.bin'
path_test_y = 'D:\\ANN\\dataset\\stl10_binary\\stl10_binary\\test_y.bin'
path_unlabeled = 'D:\\ANN\\dataset\\stl10_binary\\stl10_binary\\unlabeled_X.bin'
path_labels_name = 'D:\\ANN\\dataset\\stl10_binary\\stl10_binary\\class_names.txt'
path_save_directory = 'D:\\ANN\\dataset\\stl10_binary\\stl10_binary\\new\\new'
# Read images (train images)
x_train = read_all_images(path_train_x)
# convert images to gray flatten
x_train = images_gray_falt_version(images=x_train)
# convert type
x_train = x_train.astype('float32') / 255.
print(x_train.shape, type(x_train))
# Read images (test images)
x_test = read_all_images(path_test_x)
# convert images to gray flatten
x_test = images_gray_falt_version(images=x_test)
# convert type
x_test = x_test.astype('float32') / 255.
print(x_test.shape, type(x_test))
# Read labels (train)
# convert images to gray flatten
# x_train = images_gray_falt_version(images=x_train)
# convert type
# x_train = x_train.astype('float32') / 255.
# print(x_train.shape, type(x_train))
# Read images (test images)
# x_test = read_all_images(path_test_x)
# convert images to gray flatten
# x_test = images_gray_falt_version(images=x_test)
# convert type
# x_test = x_test.astype('float32') / 255.
# print(x_test.shape, type(x_test))
# Read images (unlabeled images)
x_unlabel = read_all_images(path_unlabeled)
# convert images to gray flatten
x_unlabel = images_gray_falt_version(images=x_unlabel)
# convert type
x_unlabel = x_unlabel.astype('float32') / 255.
print(x_unlabel.shape, type(x_unlabel))
# Read labels (train)
# y_train = read_labels(path_train_y)
# print(y_train.shape)
# Read labels (train)
# y_test = read_labels(path_test_y)
# print(y_test.shape)
# train and validation
X[i, :, :, :] = X[j, :, :, :]
X[j, :, :, :] = tmp
tmp = Y[i:i + 1].copy()
Y[i] = Y[j]
Y[j] = tmp
TrainX = np.zeros((24000, 96, 96, 3), dtype=np.uint8)
TrainY = np.zeros((24000, 1), dtype=np.uint8)
s = 0
TrainX[s:s + 12000] = np.array(load_zipped_pickle('UECTrainInstance.gz')).astype(dtype=np.uint8)
TrainY[s:s + 12000] = np.ones([12000, 1])
s += 12000
TrainX[s:s + 5000] = np.array(stl10_input.read_all_images('stl10_binary/train_X.bin')[:5000]).astype(dtype=np.uint8)
TrainY[s:s + 5000] = np.zeros([5000, 1])
s += 5000
TrainX[s:s + 7000] = np.array(load_zipped_pickle('MITTrainInstance.gz')).astype(dtype=np.uint8)
TrainY[s:s + 7000] = np.zeros([7000, 1])
shuffle(TrainX, TrainY)
TrainX.tofile('train_images.bin')
TrainY.tofile('train_labels.bin')
TestX = np.zeros((4000, 96, 96, 3), dtype=np.uint8)
TestY = np.zeros((4000, 1), dtype=np.uint8)
s = 0
def load_unlabeld_data():
data = stl10_input.read_all_images(unlabeled_X_path)
return data
import numpy as np
import keras
from keras.engine import Model
from keras.layers import Dense, Flatten, Dropout
from keras import optimizers
import pandas as pd
from keras.applications.vgg16 import VGG16
from keras.preprocessing import image
from keras.applications.vgg16 import preprocess_input
from keras.applications.vgg16 import decode_predictions
import stl10_input
# Download the data required
stl10_input.download_and_extract()
x_train = stl10_input.read_all_images('data/stl10_binary/train_X.bin')
y_train = stl10_input.read_labels('data/stl10_binary/train_y.bin')
x_test = stl10_input.read_all_images('data/stl10_binary/test_X.bin')
y_test = stl10_input.read_labels('data/stl10_binary/test_y.bin')
# unlabeled = stl10_input.read_all_images('data/stl10_binary/unlabeled_X.bin')
print(x_train.shape)
print(y_train.shape)
print(x_test.shape)
print(y_test.shape)
# print(unlabeled.shape)
# Model
model = VGG16(weights='imagenet',
include_top=False,
input_shape=(96, 96, 3),
classes=10)
def train():
#
fileName = "data\\train_X.bin"
X_train = read_all_images(fileName)
testFile = "data\\test_X.bin"
X_test = read_all_images(testFile)
test_y_File = "data\\test_y.bin"
targets = read_labels(test_y_File)
# mnist = fetch_openml('mnist_784', version=1, cache=True)
# targets = mnist.target[60000:]
#
# X_train = mnist.data[:60000]
# X_test = mnist.data[60000:]
script_directory = os.path.split(os.path.abspath(__file__))[0]
colons = []
optimizers = []
colons_paths = []
filepath = 'encoders\\encoder_' + str(0) + '.model'
predictor_model = os.path.join(script_directory, filepath)
colons_paths.append(predictor_model)
input = 4126
#input = 1152
# c = Ensemble()
# c.cuda()
c = EncoderSTL(3, input)
c.cuda()
colons.append(c)
# c2 = EncoderSTL(3, input)
# c2.cuda()
# colons.append(c2)
#
# c3 = EncoderSTL(3, input)
# c3.cuda()
# colons.append(c3)
#
# c4 = EncoderSTL(3, input)
# c4.cuda()
# colons.append(c4)
optimizer = torch.optim.Adam(c.parameters(), lr=LEARNING_RATE_DEFAULT)
optimizers.append(optimizer)
# optimizer2 = torch.optim.Adam(c2.parameters(), lr=LEARNING_RATE_DEFAULT)
# optimizers.append(optimizer2)
#
# optimizer3 = torch.optim.Adam(c3.parameters(), lr=LEARNING_RATE_DEFAULT)
# optimizers.append(optimizer3)
#
# optimizer4 = torch.optim.Adam(c4.parameters(), lr=LEARNING_RATE_DEFAULT)
# optimizers.append(optimizer4)
max_loss = 1999
for iteration in range(MAX_STEPS_DEFAULT):
ids = np.random.choice(len(X_train),
size=BATCH_SIZE_DEFAULT,
replace=False)
train = True
p1, p2, p3, p4, mim = forward_block(X_train, ids, colons, optimizers,
train, BATCH_SIZE_DEFAULT)
p1, p2, p3, p4, mim = forward_block(X_train, ids, colons, optimizers,
train, BATCH_SIZE_DEFAULT, p1, p2,
p3, p4)
p1, p2, p3, p4, mim = forward_block(X_train, ids, colons, optimizers,
train, BATCH_SIZE_DEFAULT, p1, p2,
p3, p4)
if iteration % EVAL_FREQ_DEFAULT == 0:
test_ids = np.random.choice(len(X_test),
size=BATCH_SIZE_DEFAULT,
replace=False)
p1, p2, p3, p4, mim = forward_block(X_test, test_ids, colons,
optimizers, False,
BATCH_SIZE_DEFAULT)
print("loss 1: ", mim.item())
p1, p2, p3, p4, mim = forward_block(X_test, test_ids, colons,
optimizers, False,
BATCH_SIZE_DEFAULT, p1, p2, p3,
p4)
print("loss 2: ", mim.item())
p1, p2, p3, p4, mim = forward_block(X_test, test_ids, colons,
optimizers, False,
BATCH_SIZE_DEFAULT, p1, p2, p3,
p4)
print("loss 3: ", mim.item())
print()
print("iteration: ", iteration)
print(p1[0])
print(p2[0])
print(p3[0])
print(p4[0])
print_info(p1, p2, p3, p4, targets, test_ids)
test_loss = mim.item()
if max_loss > test_loss:
max_loss = test_loss
print("models saved iter: " + str(iteration))
# for i in range(number_colons):
# torch.save(colons[i], colons_paths[i])
print("test loss " + str(test_loss))
print("")
def load_unlabeld_data(grayscale = False):
data = stl10_input.read_all_images(unlabeled_X_path)
if grayscale:
return grayScaler(data[:2000])/255.0
else:
return data[:2000]/255.0
def train():
#
fileName = "..\\data\\train_X.bin"
X_train = read_all_images(fileName)
testFile = "..\\data\\test_X.bin"
X_test = read_all_images(testFile)
test_y_File = "..\\data\\test_y.bin"
targets = read_labels(test_y_File)
# mnist = fetch_openml('mnist_784', version=1, cache=True)
# targets = mnist.target[60000:]
#
# X_train = mnist.data[:60000]
# X_test = mnist.data[60000:]
script_directory = os.path.split(os.path.abspath(__file__))[0]
colons = []
optimizers = []
colons_paths = []
filepath = 'encoders\\encoder_' + str(0) + '.model'
predictor_model = os.path.join(script_directory, filepath)
colons_paths.append(predictor_model)
input = 4106
#input = 1152
c = Specialist(3, input)
c = c.cuda()
colons.append(c)
c2 = Specialist(3, input)
c2 = c2.cuda()
colons.append(c2)
c3 = Specialist(3, input)
c3.cuda()
colons.append(c3)
c4 = Specialist(3, input)
c4.cuda()
colons.append(c4)
c5 = Specialist(3, input)
c5.cuda()
colons.append(c5)
c6 = Specialist(3, input)
c6.cuda()
colons.append(c6)
c7 = Specialist(3, input)
c7.cuda()
colons.append(c7)
c8 = Specialist(3, input)
c8.cuda()
colons.append(c8)
c9 = Specialist(3, input)
c9.cuda()
colons.append(c9)
c0 = Specialist(3, input)
c0.cuda()
colons.append(c0)
optimizer = torch.optim.Adam(c.parameters(), lr=LEARNING_RATE_DEFAULT)
optimizers.append(optimizer)
optimizer2 = torch.optim.Adam(c2.parameters(), lr=LEARNING_RATE_DEFAULT)
optimizers.append(optimizer2)
optimizer3 = torch.optim.Adam(c3.parameters(), lr=LEARNING_RATE_DEFAULT)
optimizers.append(optimizer3)
optimizer4 = torch.optim.Adam(c4.parameters(), lr=LEARNING_RATE_DEFAULT)
optimizers.append(optimizer4)
optimizer5 = torch.optim.Adam(c5.parameters(), lr=LEARNING_RATE_DEFAULT)
optimizers.append(optimizer5)
optimizer6 = torch.optim.Adam(c6.parameters(), lr=LEARNING_RATE_DEFAULT)
optimizers.append(optimizer6)
optimizer7 = torch.optim.Adam(c7.parameters(), lr=LEARNING_RATE_DEFAULT)
optimizers.append(optimizer7)
optimizer8 = torch.optim.Adam(c8.parameters(), lr=LEARNING_RATE_DEFAULT)
optimizers.append(optimizer8)
optimizer9 = torch.optim.Adam(c9.parameters(), lr=LEARNING_RATE_DEFAULT)
optimizers.append(optimizer9)
optimizer0 = torch.optim.Adam(c0.parameters(), lr=LEARNING_RATE_DEFAULT)
optimizers.append(optimizer0)
max_loss = 1999
for iteration in range(MAX_STEPS_DEFAULT):
ids = np.random.choice(len(X_train), size=BATCH_SIZE_DEFAULT, replace=False)
train = True
products, mim = forward_block(X_train, ids, colons, optimizers, train, BATCH_SIZE_DEFAULT)
p1, p2, p3, p4, p5, p6, p7, p8, p9, p0 = products
products, mim = forward_block(X_train, ids, colons, optimizers, train, BATCH_SIZE_DEFAULT, p1, p2, p3, p4, p5, p6, p7, p8, p9, p0)
p1, p2, p3, p4, p5, p6, p7, p8, p9, p0 = products
products, mim = forward_block(X_train, ids, colons, optimizers, train, BATCH_SIZE_DEFAULT, p1, p2, p3, p4, p5, p6, p7, p8, p9, p0)
if iteration % EVAL_FREQ_DEFAULT == 0:
# print_dict = {"0": "", "1": "", "2": "", "3": "", "4": "", "5": "", "6": "", "7": "", "8": "", "9": ""}
print_dict = {1: "", 2: "", 3: "", 4: "", 5: "", 6: "", 7: "", 8: "", 9: "", 10: ""}
test_ids = np.random.choice(len(X_test), size=BATCH_SIZE_DEFAULT, replace=False)
products, mim = forward_block(X_test, test_ids, colons, optimizers, False, BATCH_SIZE_DEFAULT)
# test_ids = np.random.choice(len(X_test), size=BATCH_SIZE_DEFAULT, replace=False)
# products, mim = forward_block(X_test, test_ids, colons, optimizers, False, BATCH_SIZE_DEFAULT)
# print_dict = gather_data(print_dict, products, targets, test_ids)
#
# test_ids = np.random.choice(len(X_test), size=BATCH_SIZE_DEFAULT, replace=False)
# products, mim = forward_block(X_test, test_ids, colons, optimizers, False, BATCH_SIZE_DEFAULT)
# print_dict = gather_data(print_dict, products, targets, test_ids)
p1, p2, p3, p4, p5, p6, p7, p8, p9, p0 = products
print("loss 1: ", mim.item())
products, mim = forward_block(X_test, test_ids, colons, optimizers, False, BATCH_SIZE_DEFAULT, p1, p2, p3, p4, p5, p6, p7, p8, p9, p0)
p1, p2, p3, p4, p5, p6, p7, p8, p9, p0 = products
print("loss 2: ", mim.item())
products, mim = forward_block(X_test, test_ids, colons, optimizers, False, BATCH_SIZE_DEFAULT, p1, p2, p3, p4, p5, p6, p7, p8, p9, p0)
print("loss 3: ", mim.item())
print()
print("iteration: ", iteration)
print_dict = gather_data(print_dict, products, targets, test_ids)
print_info(print_dict)
test_loss = mim.item()
if max_loss > test_loss:
max_loss = test_loss
print("models saved iter: " + str(iteration))
# for i in range(number_colons):
# torch.save(colons[i], colons_paths[i])
print("test loss " + str(test_loss))
print("")
def load_unlabeld_data(grayscale=False):
data = stl10_input.read_all_images(unlabeled_X_path)
if grayscale:
return grayScaler(data[:2000]) / 255.0
else:
return data[:2000] / 255.0
path_test_x = 'D:\\ANN\\dataset\\stl10_binary\\stl10_binary\\test_X.bin'
path_test_y = 'D:\\ANN\\dataset\\stl10_binary\\stl10_binary\\test_y.bin'
path_unlabeled = 'D:\\ANN\\dataset\\stl10_binary\\stl10_binary\\unlabeled_X.bin'
path_labels_name = 'D:\\ANN\\dataset\\stl10_binary\\stl10_binary\\class_names.txt'
path_save_directory = 'D:\\ANN\\dataset\\stl10_binary\\stl10_binary\\new\\new'
# Read images (train images)
# x_train = read_all_images(path_train_x)
# convert images to gray flatten
# x_train = images_gray_falt_version(images=x_train)
# convert type
# x_train = x_train.astype('float32') / 255.
# print(x_train.shape, type(x_train))
# Read images (test images)
x_test = read_all_images(path_test_x)
# convert images to gray flatten
x_test = images_gray_falt_version(images=x_test)
# convert type
x_test = x_test.astype('float32') / 255.
print(x_test.shape, type(x_test))
# Read images (unlabeled images)
x_unlabel = read_all_images(path_unlabeled)
# convert images to gray flatten
x_unlabel = images_gray_falt_version(images=x_unlabel)
# convert type
x_unlabel = x_unlabel.astype('float32') / 255.
print(x_unlabel.shape, type(x_unlabel))
# Read labels (train)
_handle_dim_ordering()
batch_size = 32
nb_classes = 10
nb_epoch = 200
data_augmentation = True
# input image dimensions
img_rows, img_cols = 96,96
# The CIFAR10 images are RGB.
img_channels = 3
from stl10_input import read_all_images,read_labels
X_train = read_all_images('/home/changjianlong/deep-unsupervised-learning/revise1/data/stl10_binary/train_X.bin')
X_test = read_all_images('/home/changjianlong/deep-unsupervised-learning/revise1/data/stl10_binary/test_X.bin')
y_train = read_labels('/home/changjianlong/deep-unsupervised-learning/revise1/data/stl10_binary/train_y.bin')-1
y_test = read_labels('/home/changjianlong/deep-unsupervised-learning/revise1/data/stl10_binary/test_y.bin')-1
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
Y_train = np_utils.to_categorical(y_train, nb_classes)
Y_test = np_utils.to_categorical(y_test, nb_classes)
# subtract mean and normalize
mean_image = np.mean(X_train, axis=0)
X_train -= mean_image
X_test -= mean_image
X_train /= 128.
X_test /= 128.