def vis_square(data,padsize=1,padval=0):
data-=data.min()
data/=data.max()
n = int(np.ceil(np.sqrt(data.shape[0])))
print("The n is %.2f"%(n))
print("The n is %.2f"%(data.ndim))
padding = ((0,n**2-data.shape[0]),(0,padsize),(0,padsize)) + ((0,0),)*(data.ndim - 3)
data = np.pad(data,padding,mode='constant',constant_values=(padval,padval))
data = data.reshape((n,n) + data.shape[1:]).transpose((0,2,1,3)+ tuple(range(4,data.ndim+1)))
data = data.reshape((n*data.shape[1],n*data.shape[3]) + data.shape[4:])
def readMSTARFile(filename):
# raw_input('Enter the mstar file to read: ')
# print filename
f = open(filename, 'rb')
a = b''
phoenix_header = []
tmp = 'PhoenixHeaderVer'
while tmp.encode() not in a:
a = f.readline()
a = f.readline()
tmp = 'EndofPhoenixHeader'
while tmp.encode() not in a:
phoenix_header.append(a)
a = f.readline()
data = np.fromfile(f, dtype='>f4')
# print data.shape
# magdata = data[:128*128]
# phasedata = data[128*128:]
# if you want to print an image
# imdata = magdata*255
# imdata = imdata.astype('uint8')
targetSerNum = '-'
for line in phoenix_header:
# print line
if ('TargetType').encode() in line:
targetType = line.strip().split(b'=')[1].strip()
elif ('TargetSerNum').encode() in line:
targetSerNum = line.strip().split(b'=')[1].strip()
elif ('NumberOfColumns').encode() in line:
cols = int(line.strip().split(b'=')[1].strip())
elif ('NumberOfRows').encode() in line:
rows = int(line.strip().split(b'=')[1].strip())
label = targetType # + '_' + targetSerNum
roffset = (rows - 128) // 2
coffset = (cols - 128) // 2
data = data[:rows * cols]
data = data.reshape((rows, cols))
data = data[roffset:(128 + roffset), coffset:(128 + coffset)]
# plt.imshow(data)
# plt.show()
return data.astype('float32'), label, targetSerNum
def vis_square(data):
data = (data - data.min()) / (data.max() - data.min())
n = int(np.ceil(np.sqrt(data.shape[0])))
padding = (((0, n**2 - data.shape[0]), (0, 1),
(0, 1)) # add some space between filters
+ ((0, 0), ) * (data.ndim - 3)
) # don't pad the last dimension (if there is one)
data = np.pad(data, padding, mode='constant',
constant_values=1) # pad with ones (white)
data = data.reshape((n, n) + data.shape[1:]).transpose(
(0, 2, 1, 3) + tuple(range(4, data.ndim + 1)))
data = data.reshape((n * data.shape[1], n * data.shape[3]) +
data.shape[4:])
plt.imshow(data)
plt.axis('off')
plt.show()
def patch_and_Gnormalize(img, patch_size, verbose=True):
"""1. Extract patches from an image
2. Cast to a 2D matrix
3. normalize the patches like normal r.v.s
Make sure that dtype(img) is float, so that normalization makes sense!
Parameters
----------
img: 3D array of float, shape (M, N, C)
Input data, M rows, N columns, C colour channels
patch_size: 2D tuple, shape (patch_width, patch_height)
Usually (10, 10)
verbose: controls verbosity. True by default.
Returns
-------
patches: 2D array of float, shape (M2, N2)
M2 ~= M*N, N2 = patch_width * patch_height * C
M2 will likely be less than M * N because of how extract_patches_2d works
"""
t0 = time.time()
if verbose:
print('image shape = %s' % (img.shape,))
#1. Extract patches
patches = extract_patches_2d(img, patch_size)
#2. Cast into 2D
patches = patches.reshape(patches.shape[0], -1)
#3. GNormalize
t1 = time.time()
patch_size = (10,10)
data = extract_patches_2d(img,patch_size)
dt = time.time() - t1
if verbose:
print('Extracted patches. Current shape = %s' % (data.shape,))
t1 = time.time()
data = data.reshape(data.shape[0],-1)
if verbose:
print('Reshaped patches. Current shape = %s' % (data.shape,))
data -= np.mean(data, axis = 0)
data /= np.std(data, axis = 0)
data[np.isnan(data)] = 0.0
dt = time.time() - t0
if verbose:
print('Total time elapsed = %.3fs.' % (time.time() - t0))
return patches
def patch_and_Gnormalize(img, patch_size, verbose=True):
"""1. Extract patches from an image
2. Cast to a 2D matrix
3. normalize the patches like normal r.v.s
Make sure that dtype(img) is float, so that normalization makes sense!
Parameters
----------
img: 3D array of float, shape (M, N, C)
Input data, M rows, N columns, C colour channels
patch_size: 2D tuple, shape (patch_width, patch_height)
Usually (10, 10)
verbose: controls verbosity. True by default.
Returns
-------
patches: 2D array of float, shape (M2, N2)
M2 ~= M*N, N2 = patch_width * patch_height * C
M2 will likely be less than M * N because of how extract_patches_2d works
"""
t0 = time.time()
if verbose:
print('image shape = %s' % (img.shape, ))
#1. Extract patches
patches = extract_patches_2d(img, patch_size)
#2. Cast into 2D
patches = patches.reshape(patches.shape[0], -1)
#3. GNormalize
t1 = time.time()
patch_size = (10, 10)
data = extract_patches_2d(img, patch_size)
dt = time.time() - t1
if verbose:
print('Extracted patches. Current shape = %s' % (data.shape, ))
t1 = time.time()
data = data.reshape(data.shape[0], -1)
if verbose:
print('Reshaped patches. Current shape = %s' % (data.shape, ))
data -= np.mean(data, axis=0)
data /= np.std(data, axis=0)
data[np.isnan(data)] = 0.0
dt = time.time() - t0
if verbose:
print('Total time elapsed = %.3fs.' % (time.time() - t0))
return patches
def loadOutputs():
global outputsData, trainButton
outputsPath = askopenfilename()
archivo = matlabIo.loadmat(outputsPath, mdict=None)
t = archivo['allTarge']
#t = archivo['Target']
data = np.uint8(t)
data = data.reshape(-1)
outputsData = data
trainButton.config(state=NORMAL)
print "Target data loaded!" + str(outputsData.shape)
def radial_profile(data, center):
y, x = np.indices((data.shape[0], data.shape[1]))
r = np.sqrt((x - center[0])**2 + (y - center[1])**2)
r = r.astype(np.int)
r = r.ravel()
data = data.reshape(-1, data.shape[-1])
lis = [[] for i in range(r.max())]
for i in range(len(lis)):
for j in range(len(r)):
if r[j] == i:
lis[i].append(data[j])
else:
pass
return lis
def GetControlledBatch(self,
my_angle,
my_x,
my_y,
delta_angle,
my_speed,
verbose=False):
start_y, start_x = self.GetControlledTrajectory(
my_angle=my_angle,
my_x=my_x,
my_y=my_y,
delta_angle=delta_angle,
my_speed=my_speed)
# minibatch data
# data_downsample = np.zeros((self.batch_size_, self.seq_length_, self.image_size_downsample_, self.image_size_downsample_), dtype=np.float32)
data = np.zeros((self.batch_size_, self.seq_length_, self.image_size_,
self.image_size_),
dtype=np.float32)
data_label = np.zeros(self.batch_size_, dtype=np.float32)
data_label_onehot = np.zeros(
(self.batch_size_, self.num_input_labels_), dtype=np.float32)
for j in range(self.batch_size_):
# get random digit from dataset
ind = self.indices_[j]
digit_image = self.data_[ind, :, :]
digit_image = rescale(digit_image, 1.0 / 2.0, anti_aliasing=False)
# generate video
for i in range(self.seq_length_):
top = start_y[i, j * self.num_digits_]
left = start_x[i, j * self.num_digits_]
bottom = top + self.digit_size_
right = left + self.digit_size_
data[j, i, top:bottom, left:right] = self.Overlap(
data[j, i, top:bottom, left:right], digit_image)
data_label_onehot[j,
np.where(
self.input_labels_ == self.labels_[ind])] = 1
data_label[j] = self.labels_[ind]
return data.reshape(self.batch_size_,
-1), data_label, data_label_onehot
def loadInputs():
global inputData, boxSize
inputsPath = askopenfilename()
archivo = matlabIo.loadmat(inputsPath, mdict=None)
image = archivo['allBlobs']
#image = archivo['Data']
data = np.uint8(image)
boxSize = len(data[0][0])
data = data.reshape(-1,1,boxSize,boxSize)
inputData = data / np.float32(256)
boxSizeIndicator.config(state=NORMAL)
boxSizeIndicator.delete(1.0, END)
boxSizeIndicator.insert(END, "Box Size: " + str(boxSize))
boxSizeIndicator.config(state=DISABLED)
print "Input data loaded!"
def show_data(npy_data):
epoch_size = 300
width = 28
length = 28
depth = 1
input_data = np.load(npy_data)
num = input_data[0:epoch_size].shape[0] # only 1 ~ 1000 to show
print(input_data[0:epoch_size, 28**2:28**2 + 1])
image = tf.placeholder(tf.float32, [epoch_size, width, length, depth],
name="image")
tf.summary.image('source_data', image, max_outputs=epoch_size) # 2
merged = tf.summary.merge_all()
writer = tf.summary.FileWriter(current_path + "showDataRow") # 3
with tf.Session() as sess:
for i in range(num // epoch_size):
data = input_data[i * epoch_size:(i + 1) * epoch_size,
0:width * length]
data = data.reshape(epoch_size, width, length, depth)
summary = sess.run(merged, feed_dict={image: data})
writer.add_summary(summary, i)
writer.close()
def plt_to_array(fig): data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='') data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,)) print data plt.imshow(data) plt.show()
def drawData(data):
plt.figure()
plt.imshow(data.reshape(28, 28))
plt.savefig("./output/num.png")
plt.close()
def load_mnist_images(filename):
with gzip.open(filename, 'rb') as f:
data = np.frombuffer(f.read(), np.uint8, offset=16)
data = data.reshape(-1,784)
return data
def show(self):
"""Show the data graphically in a new pop-up window."""
# prevent the following error:
# '_tkinter.TclError: no display name and no $DISPLAY environment
# variable'
# import matplotlib
# matplotlib.use('GTK3Agg', warn=False)
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
pointlist = self.get_pointlist()
if 'pen_down' in pointlist[0][0]:
assert len(pointlist) > 1, \
"Lenght of pointlist was %i. Got: %s" % (len(pointlist),
pointlist)
# Create a new pointlist that models pen-down strokes and pen
# up strokes
new_pointlist = []
last_pendown_state = None
stroke = []
for point in pointlist[0]:
if last_pendown_state is None:
last_pendown_state = point['pen_down']
if point['pen_down'] != last_pendown_state:
new_pointlist.append(stroke)
last_pendown_state = point['pen_down']
stroke = []
else:
stroke.append(point)
new_pointlist.append(stroke) # add the last stroke
pointlist = new_pointlist
_, ax = plt.subplots()
ax.set_title("Raw data id: %s, "
"Formula_id: %s" %
(str(self.raw_data_id), str(self.formula_id)))
colors = _get_colors(self.segmentation)
for symbols, color_1 in zip(self.segmentation, colors):
# print "Symbol: {}".format(self.inv_mapping[tuple(symbols)])
fig = plt.figure()
ax = fig.add_subplot(111)
for stroke_index in symbols:
stroke = pointlist[stroke_index]
xs, ys = [], []
for p in stroke:
xs.append(p['x'])
ys.append(p['y'])
ax.plot(xs, ys, color="#000000")
# if "pen_down" in stroke[0] and stroke[0]["pen_down"] is False:
# ax.plot(xs, ys, '-x', color=color)
# else:
# ax.plot(xs, ys, '-x', color=color)
# print xs,ys
# Make a random plot...
# If we haven't already shown or saved the plot, then we need to
# draw the figure first...
plt.gca().invert_yaxis()
ax.set_aspect('equal')
plt.axis('off')
fig.canvas.draw()
# fig.savefig("test_fig.png")
np.set_printoptions(threshold=np.nan)
# Now we can save it to a numpy array.
# non_grey = []
data = np.fromstring(fig.canvas.tostring_rgb(),
dtype=np.uint8,
sep='')
# print data
# print fig.canvas.get_width_height()
# print data.shape
data = data.reshape(fig.canvas.get_width_height()[::-1] + (3, ))
data = np.dot(data[..., :3], [0.299, 0.587, 0.114])
print data.shape
data_dict = defaultdict(int)
new_data = np.zeros(data.shape)
for row in range(len(data)):
for col in range(len(data[0])):
point = data[row][col]
# if point != 191:
# new_data[row][col] = 0
if point != 191:
new_data[row][col] = 1
data_dict[(row, col)] = 1
# print list(itertools.chain.from_iterable(new_data))
# plt.imshow(new_data, cmap=plt.get_cmap('gray'))
# plt.savefig("current_{}".format(symbols))
break
plt.hist(labels, 32)
plt.show()
plt.figure(figsize=(10,10))
legos=[300, 2250, 3650, 4000]
for i in range(len(legos)):
plt.subplot(5,5,i+1)
plt.xticks([])
plt.yticks([])
plt.grid(False)
plt.imshow(images[i], cmap=plt.cm.binary)
plt.xlabel(lego_classes[labels[i]])
plt.show()
# scale the raw pixel intensities to the range [0, 1]
data = np.array(data, dtype="float") / 255.0
print(data.shape)
data64 = data.reshape(data.shape[0],200,200,1)
data64 = np.array(data64)
#Encode labels
en = LabelEncoder()
labels = en.fit_transform(labels)
labels = np.array(labels)
# partition the data into training and testing splits using 75% of
# the data for training and the remaining 25% for testing
(trainX, testX, trainY, testY) = train_test_split(data64,
labels, test_size=0.25, random_state=42)#Only Used the dataset marked 'Train' my pc has low amounts of RAM
# Define model architecture
def plot_traces_v2(strokes):
"""Show the data graphically in a new pop-up window."""
# prevent the following error:
# '_tkinter.TclError: no display name and no $DISPLAY environment
# variable'
# import matplotlib
# matplotlib.use('GTK3Agg', warn=False)
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import numpy as np
plt.rcParams['axes.facecolor'] = 'red'
x, y = [], []
fig = plt.figure()
ax = fig.add_subplot(111)
for stroke_index in range(len(strokes)):
stroke = strokes[stroke_index]
xs, ys = [], []
for p in stroke:
xs.append(p['x'])
ys.append(p['y'])
ax.plot(xs, ys, color="#000000")
# If we haven't already shown or saved the plot, then we need to
# draw the figure first...
plt.gca().invert_yaxis()
ax.set_aspect('equal')
plt.axis('off')
fig.canvas.draw()
# fig.savefig("results/"+symbol_str+".png",facecolor=ax.get_facecolor())
# np.set_printoptions(threshold=np.nan)
# Now we can save it to a numpy array.
# non_grey = []
data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
# print data
# print fig.canvas.get_width_height()
# print data.shape
data = data.reshape(fig.canvas.get_width_height()[::-1] + (3, ))
# data = np.dot(data[..., :3], [0.299, 0.587, 0.114])
# print data.shape
'''
data_dict = defaultdict(int)
new_data = np.zeros(data.shape)
flipped_data = np.zeros(data.shape)
# print data
for row in range(len(data)):
for col in range(len(data[0])):
point = data[row][col]
if point != 255:
flipped_data[row][col] = 0
else:
flipped_data[row][col] = 1
if point != 255:
new_data[row][col] = 1
data_dict[(row, col)] = 1
'''
# blurred = gaussian_filter(new_data, sigma=7)
# im = Image.fromarray(blurred * 255)
# im.show()
# print new_data.shape
# im = Image.fromarray(new_data*255)
# im.show()
# new_data = new_data[:, 100:-100]
# flipped_data = flipped_data[:,100:-100]
# plt.savefig("results/"+symbol_str)
image = color.rgb2gray(data)
fd, hog_image = hog(image,
orientations=8,
pixels_per_cell=(32, 32),
cells_per_block=(1, 1),
visualise=True)
# Rescale histogram for better display
hog_image_rescaled = exposure.rescale_intensity(hog_image,
in_range=(0, 0.02))
hog_np_array = np.asarray(hog_image_rescaled)
return hog_np_array
def get_training_example(self):
"""Show the data graphically in a new pop-up window."""
# prevent the following error:
# '_tkinter.TclError: no display name and no $DISPLAY environment
# variable'
# import matplotlib
# matplotlib.use('GTK3Agg', warn=False)
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
plt.rcParams['axes.facecolor'] = 'red'
from scipy.ndimage.filters import gaussian_filter
x, y = [], []
pointlist = self.get_pointlist()
if 'pen_down' in pointlist[0][0]:
assert len(pointlist) > 1, \
"Lenght of pointlist was %i. Got: %s" % (len(pointlist),
pointlist)
# Create a new pointlist that models pen-down strokes and pen
# up strokes
new_pointlist = []
last_pendown_state = None
stroke = []
for point in pointlist[0]:
if last_pendown_state is None:
last_pendown_state = point['pen_down']
if point['pen_down'] != last_pendown_state:
new_pointlist.append(stroke)
last_pendown_state = point['pen_down']
stroke = []
else:
stroke.append(point)
new_pointlist.append(stroke) # add the last stroke
pointlist = new_pointlist
_, ax = plt.subplots()
ax.set_title("Raw data id: %s, "
"Formula_id: %s" %
(str(self.raw_data_id), str(self.formula_id)))
colors = _get_colors(self.segmentation)
fig = plt.figure()
for symbols, color_1 in zip(self.segmentation, colors):
symbol_str = self.inv_mapping[tuple(sorted(symbols))]
plt.clf()
ax = fig.add_subplot(111)
# fig.set_size_inches([124.0 / 192, 93.0 / 192])
# fig.set_size_inches([62.0 / 192, 62.0 / 192])
for stroke_index in symbols:
stroke = pointlist[stroke_index]
xs, ys = [], []
for p in stroke:
xs.append(p['x'])
ys.append(p['y'])
ax.plot(xs, ys, color="#000000")
# If we haven't already shown or saved the plot, then we need to
# draw the figure first...
plt.gca().invert_yaxis()
ax.set_aspect('equal')
plt.axis('off')
fig.canvas.draw()
# fig.savefig("results/"+symbol_str+".png",facecolor=ax.get_facecolor())
# np.set_printoptions(threshold=np.nan)
# Now we can save it to a numpy array.
# non_grey = []
data = np.fromstring(fig.canvas.tostring_rgb(),
dtype=np.uint8,
sep='')
# print data
# print fig.canvas.get_width_height()
# print data.shape
data = data.reshape(fig.canvas.get_width_height()[::-1] + (3, ))
# data = np.dot(data[..., :3], [0.299, 0.587, 0.114])
# print data.shape
'''
data_dict = defaultdict(int)
new_data = np.zeros(data.shape)
flipped_data = np.zeros(data.shape)
# print data
for row in range(len(data)):
for col in range(len(data[0])):
point = data[row][col]
if point != 255:
flipped_data[row][col] = 0
else:
flipped_data[row][col] = 1
if point != 255:
new_data[row][col] = 1
data_dict[(row, col)] = 1
'''
# blurred = gaussian_filter(new_data, sigma=7)
# im = Image.fromarray(blurred * 255)
# im.show()
# print new_data.shape
# im = Image.fromarray(new_data*255)
# im.show()
# new_data = new_data[:, 100:-100]
# flipped_data = flipped_data[:,100:-100]
# plt.savefig("results/"+symbol_str)
image = color.rgb2gray(data)
fd, hog_image = hog(image,
orientations=8,
pixels_per_cell=(32, 32),
cells_per_block=(1, 1),
visualise=True)
# Rescale histogram for better display
hog_image_rescaled = exposure.rescale_intensity(hog_image,
in_range=(0, 0.02))
hog_np_array = np.asarray(hog_image_rescaled)
# plt.imshow(hog_image_rescaled, cmap=plt.cm.gray)
# plt.show()
# plt.savefig("hog_image_{}.png".format(symbol_str))
x.append(hog_np_array)
y.append(symbol_str)
return x, y
def get_training_example_v4(self, dir):
"""Show the data graphically in a new pop-up window."""
# prevent the following error:
# '_tkinter.TclError: no display name and no $DISPLAY environment
# variable'
# import matplotlib
# matplotlib.use('GTK3Agg', warn=False)
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from scipy.ndimage.filters import gaussian_filter
x, y = [], []
pointlist = self.get_pointlist()
if 'pen_down' in pointlist[0][0]:
assert len(pointlist) > 1, \
"Lenght of pointlist was %i. Got: %s" % (len(pointlist),
pointlist)
# Create a new pointlist that models pen-down strokes and pen
# up strokes
new_pointlist = []
last_pendown_state = None
stroke = []
for point in pointlist[0]:
if last_pendown_state is None:
last_pendown_state = point['pen_down']
if point['pen_down'] != last_pendown_state:
new_pointlist.append(stroke)
last_pendown_state = point['pen_down']
stroke = []
else:
stroke.append(point)
new_pointlist.append(stroke) # add the last stroke
pointlist = new_pointlist
_, ax = plt.subplots()
ax.set_title("Raw data id: %s, "
"Formula_id: %s" %
(str(self.raw_data_id), str(self.formula_id)))
colors = _get_colors(self.segmentation)
fig = plt.figure()
for symbols, color_1 in zip(self.segmentation, colors):
symbol_str = self.inv_mapping[tuple(sorted(symbols))]
plt.clf()
ax = fig.add_subplot(111)
# fig.set_size_inches([62.0 / 192, 62.0 / 192])
for stroke_index in symbols:
stroke = pointlist[stroke_index]
xs, ys = [], []
for p in stroke:
xs.append(p['x'])
ys.append(p['y'])
ax.plot(xs, ys, color="#000000")
# If we haven't already shown or saved the plot, then we need to
# draw the figure first...
plt.gca().invert_yaxis()
ax.set_aspect('equal')
plt.axis('off')
fig.canvas.draw()
# fig.savefig("results/"+symbol_str+".png",facecolor=ax.get_facecolor())
# np.set_printoptions(threshold=np.nan)
# Now we can save it to a numpy array.
# non_grey = []
data = np.fromstring(fig.canvas.tostring_rgb(),
dtype=np.uint8,
sep='')
plt.clf()
# print data
# print fig.canvas.get_width_height()
# print data.shape
data = data.reshape(fig.canvas.get_width_height()[::-1] + (3, ))
image = color.rgb2gray(data)
fd, hog_image = hog(image,
orientations=8,
pixels_per_cell=(32, 32),
cells_per_block=(1, 1),
visualise=True)
# Rescale histogram for better display
hog_image_rescaled = exposure.rescale_intensity(hog_image,
in_range=(0, 0.02))
hog_np_array = np.asarray(hog_image_rescaled)
print symbol_str
if symbol_str == '/':
symbol_str = 'forward_slash'
plt.imshow(hog_np_array, cmap='gray')
filename = dir + "_" + self.filename + symbol_str + '.png'
plt.savefig(filename, format='png', facecolor=ax.get_facecolor())
#print hog_np_array.shape
x.append(filename)
y.append(symbol_str)
# downsample for higher speed
face = face[::4, ::4] + face[1::4, ::4] + face[::4, 1::4] + face[1::4, 1::4]
face /= 4.0
height, width = face.shape
# Distort the right half of the image
print('Distorting image...')
distorted = face.copy()
distorted[:, width // 2:] += 0.075 * np.random.randn(height, width // 2)
# Extract all reference patches from the left half of the image
print('Extracting reference patches...')
t0 = time()
patch_size = (7, 7)
data = extract_patches_2d(distorted[:, :width // 2], patch_size)
data = data.reshape(data.shape[0], -1)
data -= np.mean(data, axis=0)
data /= np.std(data, axis=0)
print('done in %.2fs.' % (time() - t0))
# #############################################################################
# Learn the dictionary from reference patches
print('Learning the dictionary...')
t0 = time()
dico = MiniBatchDictionaryLearning(n_components=100, alpha=1, n_iter=500)
V = dico.fit(data).components_
dt = time() - t0
print('done in %.2fs.' % dt)
plt.figure(figsize=(4.2, 4))
import os
import numpy as np
from skimage import io, data, measure, color, filters, morphology, segmentation
from PIL import Image
import matplotlib.pyplot as plt
data_num = 10000
fig_w = 45
data = np.fromfile("mnist_test_data0", dtype=np.uint8)
label = np.fromfile("mnist_test_label", dtype=np.uint8)
print(data.shape)
print(label.shape)
data = data.reshape(data_num, fig_w, fig_w)
print("After reshape:", data.shape)
imagenum = data.shape[0]
resfile = np.zeros([data_num, fig_w, fig_w], dtype=np.uint8)
for i in range(imagenum):
print(i)
img = data[i]
m, n = img.shape
bw = np.zeros([m, n])
for k in range(m):
for j in range(n):
if img[k][j] > 0:
bw[k][j] = 1
#china = imageio.imread('custom_image.jpg')
from sklearn.datasets import load_sample_image
### loading image sample from avaliable dataset
Image = load_sample_image('flower.jpg')
### used to get the pixel value of image
print(Image.shape)
### Original picture
#io.imshow(Image)
#plt.show()
### Normaliazing the original image
data = Image / 255.0
### converting 3D matrix into 2D
data = data.reshape(640 * 427, 3)
import warnings
warnings.simplefilter('ignore')
### import clustering from scikit
from sklearn.cluster import MiniBatchKMeans
### can be compressed further by incrasing the number of the cluster
kmean = MiniBatchKMeans(8)
### fitting the data into Kmean
kmean.fit(data)
#### clustering the datapoints
new_colors = kmean.cluster_centers_[kmean.predict(data)]
#### converting back to 3D matrix
Image_recoloyred = new_colors.reshape(Image.shape)
### plotting the output
data = mnist.data[::30]
target = mnist.target[::30]
model = Isomap(n_components=2)
proj = model.fit_transform(data)
plt.scatter(proj[:, 0], proj[:, 1])
# %%
data = mnist.data[mnist.target == 1][::4]
fig, ax = plt.subplots(figsize=(10, 10))
model = Isomap(n_neighbors=5, n_components=2, eigen_solver="dense")
plot_components(
data,
model,
images=data.reshape((-1, 28, 28)),
ax=ax,
thumb_frac=0.05,
cmap="gray_r",
)
# %%
X, y_true = make_blobs(n_samples=300,
centers=4,
cluster_std=0.6,
random_state=0)
plt.scatter(X[:, 0], X[:, 1], s=50)
# %%
kmeans = KMeans(n_clusters=4)
kmeans.fit(X)
