def main():
# read data
train_images, train_labels, test_images, test_labels, class_list = data.import_data(
FLAGS.use_classes)
print('Training image size:', train_images.shape)
print('Testing_image size:', test_images.shape)
kernel_sizes = saab.parse_list_string(FLAGS.kernel_sizes)
stride = FLAGS.stride
if FLAGS.num_kernels:
num_kernels = saab.parse_list_string(FLAGS.num_kernels)
else:
num_kernels = None
energy_percent = FLAGS.energy_percent
use_num_images = FLAGS.use_num_images
print('Parameters:')
print('use_classes:', class_list)
print('Kernel_sizes:', kernel_sizes)
print('Stride:', stride)
print('Number_kernels:', num_kernels)
print('Energy_percent:', energy_percent)
print('Number_use_images:', use_num_images)
pca_params = saab.multi_Saab_transform(train_images, train_labels,
kernel_sizes=kernel_sizes,
stride=stride,
num_kernels=num_kernels,
energy_percent=energy_percent,
use_num_images=use_num_images,
use_classes=class_list)
# save data
fw = open('pca_params.pkl', 'wb')
pickle.dump(pca_params, fw)
fw.close()
def import_data(use_classes):
(train_images, train_labels), (test_images,
test_labels) = mnist.load_data()
train_images = train_images.reshape(-1, 28, 28, 1)
test_images = test_images.reshape(-1, 28, 28, 1)
train_images = train_images / 255.
test_images = test_images / 255.
train_images = np.float32(train_images)
test_images = np.float32(test_images)
print 'initiali dtype: ', train_images.dtype
# print(train_images.shape) # 60000*28*28*1
# zeropadding
train_images = np.pad(train_images, ((0, 0), (2, 2), (2, 2), (0, 0)),
mode='constant')
test_images = np.pad(test_images, ((0, 0), (2, 2), (2, 2), (0, 0)),
mode='constant')
# print(train_images.shape) # 60000*32*32*1
if use_classes != '0-9':
class_list = saab.parse_list_string(use_classes)
train_images, train_labels = get_data_for_class(
train_images, train_labels, class_list)
test_images, test_labels = get_data_for_class(test_images, test_labels,
class_list)
# print(class_list)
else:
class_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
return train_images, train_labels, test_images, test_labels, class_list
def main():
# read data
train_images, train_labels, test_images, test_labels, class_list = data.import_data(
FLAGS.use_classes)
print('Training image size:', train_images.shape)
print('Testing_image size:', test_images.shape)
kernel_sizes = saab.parse_list_string(FLAGS.kernel_sizes)
if FLAGS.num_kernels:
num_kernels = saab.parse_list_string(FLAGS.num_kernels)
else:
num_kernels = None
energy_percent = FLAGS.energy_percent
use_num_images = FLAGS.use_num_images
print('Parameters:')
print('use_classes:', class_list)
print('Kernel_sizes:', kernel_sizes)
print('Number_kernels:', num_kernels)
print('Energy_percent:', energy_percent)
print('Number_use_images:', use_num_images)
#Level_filter=np.array([1,4,6,4,1])
#Edge_filter=np.array([-1,-2, 0 ,2, 1])
#Spot_filter=np.array([-1, 0, 2, 0, -1])
Wave_filter = np.array([-1, 2, 0, -2, 1])
Ripple_filter = np.array([1, -4, 6, -4, 1])
Filter = Wave_filter.T * Ripple_filter
'''
Filter1=Level_filter.T*Level_filter
Filter3=Level_filter.T*Spot_filter
Filter4=Level_filter.T*Wave_filter
Filter5=Level_filter.T*Ripple_filter
Filter6=Edge_filter.T*Level_filter
Filter7=Edge_filter.T*Edge_filter
Filter8=Edge_filter.T*Spot_filter
Filter9=Edge_filter.T*Wave_filter
Filter10=Edge_filter.T*Ripple_filter
Filter11=Spot_filter.T*Level_filter
Filter12=Spot_filter.T*Edge_filter
Filter13=Spot_filter.T*Spot_filter
Filter14=Spot_filter.T*Wave_filter
Filter15=Spot_filter.T*Ripple_filter
Filter16=Wave_filter.T*Level_filter
Filter17=Wave_filter.T*Edge_filter
Filter18=Wave_filter.T*Spot_filter
Filter19=Wave_filter.T*Wave_filter
Filter20=Wave_filter.T*Ripple_filter
Filter21=Ripple_filter.T*Level_filter
Filter22=Ripple_filter.T*Edge_filter
Filter23=Ripple_filter.T*Spot_filter
Filter24=Ripple_filter.T*Wave_filter
Filter25=Ripple_filter.T*Ripple_filter
'''
altered_train = train_images.copy()
for i in range(train_images.shape[0]):
altered_train[i, :, :, 0] = cv2.filter2D(train_images[i, :, :, 0], -1,
Filter)
train_images = altered_train.copy()
pca_params = saab.multi_Saab_transform(train_images,
train_labels,
kernel_sizes=kernel_sizes,
num_kernels=num_kernels,
energy_percent=energy_percent,
use_num_images=use_num_images,
use_classes=class_list)
# save data
fw = open('pca_params_10.pkl', 'wb')
pickle.dump(pca_params, fw)
fw.close()
# load data
fr = open('pca_params_10.pkl', 'rb')
data1 = pickle.load(fr)
print(data1)
fr.close()
def main():
# read data
train_images, train_labels, test_images, test_labels, class_list = data.import_data(FLAGS.use_classes)
print('Training image size:', train_images.shape)
print('Testing_image size:', test_images.shape)
train_images = train_images[:6000]
train_labels = train_labels[:6000]
kernel_sizes=saab.parse_list_string(FLAGS.kernel_sizes)
if FLAGS.num_kernels:
num_kernels=saab.parse_list_string(FLAGS.num_kernels)
else:
num_kernels=None
energy_percent=FLAGS.energy_percent
use_num_images=FLAGS.use_num_images
print('Parameters:')
print('use_classes:', class_list)
print('Kernel_sizes:', kernel_sizes)
print('Number_kernels:', num_kernels)
print('Energy_percent:', energy_percent)
print('Number_use_images:', use_num_images)
def creating_law_filters(a,b):
ten_product = np.tensordot(a,b,axes=0);
return ten_product;
#Function to apply Boundary Extension
def boundary_extension(Image,n):
Ext_image = np.zeros((Row_Size+(2*n),Column_Size+(2*n)))
#Complete image
#Ext_image = np.pad(Image,n,'reflect');
for i in range(n,(Row_Size+n)):
for j in range(n,(Column_Size+n)):
Ext_image[i][j] = Image[i-n][j-n];
#Upper rows
for i in range(0,n):
for j in range(n, (Column_Size+n)):
Ext_image[i][j] = Image[0][j-n];
#Left columns
for j in range(0,n):
for i in range(n, (Row_Size+n)):
Ext_image[i][j] = Image[i-n][0];
#Bottom rows
for i in range(Row_Size+n, (Row_Size+(2*n))):
for j in range(n,(Column_Size+n)):
Ext_image[i][j] = Image[Row_Size-1][j-n];
#Right columns
for j in range(Column_Size+n, Column_Size+(2*n)):
for i in range(n,(Row_Size+n)):
Ext_image[i][j] = Image[i-n][Column_Size-1];
#Corners
for i in range(0,n):
for j in range(0,n):
Ext_image[i][j] = Image[0][0];
for i in range(0,n):
for j in range(Column_Size+n,Column_Size+(2*n)):
Ext_image[i][j] = Image[0][Column_Size-1];
for j in range(0,n):
for i in range(Row_Size+n,Row_Size+(2*n)):
Ext_image[i][j] = Image[Row_Size-1][0];
for j in range(Column_Size+n, Column_Size+(2*n)):
for i in range(Row_Size+n, Row_Size+(2*n)):
Ext_image[i][j] = Image[Row_Size-1][Column_Size-1];
return Ext_image;
def law_filter_application(Ext_image,Law_filter):
Law_applied = np.zeros((Row_Size,Column_Size))
for i in range(2, Row_Size+2):
for j in range(2, Column_Size+2):
m = 0;
k = 0;
l = 0;
for k in range(i-2, i+3):
n = 0;
for l in range(j-2, j+3):
Law_applied[i-2][j-2] = Law_applied[i-2][j-2] + (Ext_image[k][l]*Law_filter[m][n]);
n += 1 ;
m += 1 ;
return Law_applied;
Row_Size = 32;
Column_Size = 32;
Window_Size = 5;
n1 = 2
features = 25;
samples = 32*32;
L5 = np.array([1, 4, 6, 4, 1]); #Level
E5 = np.array([-1, -2, 0, 2, 1]); #Edge
S5 = np.array([-1, 0, 2, 0, -1]); #Spot
W5 = np.array([-1, 2, 0, -2, 1]); #Wave
R5 = np.array([1, -4, 6, -4, 1]);
#L5S5 = creating_law_filters(L5,S5);
L5W5 = creating_law_filters(L5,W5);
#Reading the image
for i in range(0,6000):
Input_image = train_images[i,:,:,0]
#Boundary extension of the image
Ext_image = boundary_extension(Input_image,n1);
#Applying the law filters
train_images[i,:,:,0] = law_filter_application(Ext_image,L5S5);
'''train_img1 = color.rgb2gray(io.imread('1.png'))
Input_image = train_img1
#Boundary extension of the image
Ext_image = boundary_extension(Input_image,n1);
#Applying the law filters
train_img1 = law_filter_application(Ext_image,L5S5)
plt.matshow(train_img1,cmap='gray') '''
pca_params=saab.multi_Saab_transform(train_images, train_labels,
kernel_sizes=kernel_sizes,
num_kernels=num_kernels,
energy_percent=energy_percent,
use_num_images=use_num_images,
use_classes=class_list)
# save data
fw=open('pca_params.pkl','wb')
pickle.dump(pca_params, fw)
fw.close()
# load data
fr=open('pca_params.pkl','rb')
data1=pickle.load(fr)
print(data1)
fr.close()
def main():
# read data
train_images, train_labels, test_images, test_labels, class_list = data.import_data(
FLAGS.use_classes)
print('Training image size:', train_images.shape)
print('Testing_image size:', test_images.shape)
#Laws Filter creation
L5 = np.array([1, 4, 6, 4, 1]).reshape(5, 1)
E5 = np.array([-1, -2, 0, 2, 1]).reshape(5, 1)
S5 = np.array([-1, 0, 2, 0, -1]).reshape(5, 1)
R5 = np.array([-1, 2, 0, -2, 1]).reshape(5, 1)
W5 = np.array([1, -4, 6, -4, 1]).reshape(5, 1)
laws_filters = {'L5': L5, 'E5': E5, 'S5': S5, 'R5': R5, 'W5': W5}
_2d_laws_filters = {}
for k1, v1 in laws_filters.items():
for k2, v2 in laws_filters.items():
_2d_laws_filters[k1 + k2] = np.matmul(v1, v2.T)
#boundary extension by pixel replication
extended_images = []
for img in train_images[:10000, :, :, 0]:
new_img = np.pad(img, 2, 'reflect')
extended_images.append(new_img)
#Laws feature extraction
final_images = []
for img in extended_images:
new_img = np.empty((1, 32, 32), np.uint8)
for i in range(2, 32 + 2):
for j in range(2, 32 + 2):
new_img[0][i - 2][j - 2] = convolve(i, j,
_2d_laws_filters['S5R5'],
img)
final_images.append(new_img)
train_images = np.vstack(final_images)
train_images = train_images.reshape(-1, 32, 32, 1)
print(train_images.shape)
kernel_sizes = saab.parse_list_string(FLAGS.kernel_sizes)
if FLAGS.num_kernels:
num_kernels = saab.parse_list_string(FLAGS.num_kernels)
else:
num_kernels = None
energy_percent = FLAGS.energy_percent
use_num_images = FLAGS.use_num_images
print('Parameters:')
print('use_classes:', class_list)
print('Kernel_sizes:', kernel_sizes)
print('Number_kernels:', num_kernels)
print('Energy_percent:', energy_percent)
print('Number_use_images:', use_num_images)
pca_params = saab.multi_Saab_transform(train_images,
train_labels,
kernel_sizes=kernel_sizes,
num_kernels=num_kernels,
energy_percent=energy_percent,
use_num_images=use_num_images,
use_classes=class_list)
#print(pca_params)
# save data
fw = open('pca_params_S5R5.pkl', 'wb')
pickle.dump(pca_params, fw)
fw.close()
