基于聚类量化的智能图像编码

一时失言乱红尘 2023-02-11 03:21 3阅读 0赞

# \-*- coding: utf-8 -*\- #

“”"  
Created on Wed Apr 22 10:27:31 2020

@author: 联想  
“”"

import tensorflow as tf  
import numpy as np  
import matplotlib.pyplot as plt  
import os  
from PIL import Image

# 自编码器部分 #

‘’’  
定义输入层 （128，128） =16384  
第一层隐含层500个  
第二层100个  
第三层500  
输出层784  
这是因为自编码就是希望神经网络自己学习图片特征，然后再用学习到的特征去组成原始图片，所以最后  
输出层是（128，128） =16384  
‘’’  
path="./outmodel/"\#文件保存路径，如果不存在就会被重建  
if not os.path.exists(path):\#如果路径不存在  
os.makedirs(path)  
input\_n=16384*3 \# 输入的数据是16384个，即（128*128）维度的  
hidden1\_n=500  
hidden2\_n=400  
leastd = int(np.sqrt(hidden2\_n))  
hidden3\_n=500  
output\_n=16384*3 \# 输入的数据也是16384个，即（128*128）维度的

learn\_rate=0.01  
train\_epoch=1001

x=tf.placeholder(tf.float32,\[None,input\_n\])  
y=tf.placeholder(tf.float32,\[None,input\_n\])  
a2 = tf.placeholder(tf.float32,\[None,hidden2\_n\])  
weights1=tf.Variable(tf.truncated\_normal(\[input\_n,hidden1\_n\],stddev=0.1))  
bias1=tf.Variable(tf.constant(0.1,shape=\[hidden1\_n\]))

weights2=tf.Variable(tf.truncated\_normal(\[hidden1\_n,hidden2\_n\],stddev=0.1))  
bias2=tf.Variable(tf.constant(0.1,shape=\[hidden2\_n\]))

weights3=tf.Variable(tf.truncated\_normal(\[hidden2\_n,hidden3\_n\],stddev=0.1))  
bias3=tf.Variable(tf.constant(0.1,shape=\[hidden3\_n\]))

weights4=tf.Variable(tf.truncated\_normal(\[hidden3\_n,output\_n\],stddev=0.1))  
bias4=tf.Variable(tf.constant(0.1,shape=\[output\_n\]))

def get\_result(x,weights1,bias1,weights2,bias2,weights3,bias3,weights4,bias4):  
a1=tf.nn.sigmoid(tf.matmul(x,weights1)+bias1)  
“a1.size:(?, 500)”  
a2=tf.nn.sigmoid(tf.matmul(a1,weights2)+bias2)  
“a2.size:(?, 100)”  
a3=tf.nn.sigmoid(tf.matmul(a2,weights3)+bias3)  
“a3.size:(?, 500)”  
y\_=tf.nn.sigmoid(tf.matmul(a3,weights4)+bias4)  
“y\_.size:(?, 16384)”  
return y\_,a2

def decoder(a2,weights3,bias3,weights4,bias4):  
a3=tf.nn.sigmoid(tf.matmul(a2,weights3)+bias3)  
“a3.size:(?, 500)”  
y\_=tf.nn.sigmoid(tf.matmul(a3,weights4)+bias4)  
“y\_.size:(?, 16384)”  
return y\_

y\_,hidOut=get\_result(x,weights1,bias1,weights2,bias2,weights3,bias3,weights4,bias4)

img\_decode = decoder(a2,weights3,bias3,weights4,bias4)

loss=tf.reduce\_mean(tf.pow(y\_-y,2))

train\_op=tf.train.RMSPropOptimizer(learn\_rate).minimize(loss)

num = 128  
img = Image.open(‘pictures/花.png’)  
img = img.resize((num,num))  
pixel = np.array(img)  
originImg = pixel/255  
pixel = pixel.reshape((num\*num , 3))/255  
pixel = pixel.reshape(pixel.shape\[0\]\*pixel.shape\[1\],-1)  
with tf.Session() as sess:  
tf.global\_variables\_initializer().run()  
for i in range(train\_epoch):  
xs = pixel.T  
if i%100 == 0:  
print(‘epoch:’,i)  
print(‘loss:’,sess.run(loss,feed\_dict=\{x:xs,y:xs\}))  
sess.run(train\_op,feed\_dict=\{x:xs,y:xs\})  
saver = tf.train.Saver() \# 准备好保存的模型  
saver.save(sess, “outmodel/out\_model”)

with tf.Session() as sess:  
tf.global\_variables\_initializer().run()  
saver = tf.train.Saver()  
saver.restore(sess, “outmodel/out\_model”)  
xt = pixel.T

yt=xt 
    encode_decode,hidden=sess.run([y_,hidOut],feed_dict={x:xt,y:yt})
    saver.save(sess, "outmodel/out_model")
    print(encode_decode.shape)
    encode_decode = encode_decode.T.reshape(16384,3).reshape(128,128,3)
    hidden = hidden.T.reshape(20,20)

fig = plt.figure(figsize=(10,5))  
plt.rcParams\[‘font.sans-serif’\]=\[‘SimHei’\]  
plt.axis(‘off’)  
plt.title(“Diagram of each process”)  
plt.subplot(141)  
plt.title(“Input Img”)  
plt.imshow(originImg)  
\#originImg = originImg\*255  
\#originImg\_img = Image.fromarray(np.uint8(originImg)).convert(‘RGB’) \# 将数组转化回图片  
\#originImg\_img.save(“orgin.bmp”) \# 将数组保存为图片  
plt.subplot(142)  
plt.title(“Middle layer”)  
plt.imshow(hidden)

# ============================================================================ #

# Kmeans部分 #

def findCloset(X, centroids):  
m = X.shape\[0\] \# 获取数据条数  
k = centroids.shape\[0\] \# 获取类别数  
idx = np.zeros(m) \# 数据X每个样本对应的类别

# 遍历所有数据，找到距离聚类中心最近的
    for i in range(m):
        min_dist = 1000000
        # 确定当前数据，离哪个中心点更近
        for j in range(k):
            # 计算当前点与k个类别中心的举例
            dist = np.sum((X[i] - centroids[j]) ** 2)
            if dist < min_dist:
                min_dist = dist
                idx[i] = j
    return idx

def setNewCenter(X, idx, k):  
\# 得到矩阵大小，初始化矩阵  
centroids = np.zeros((k)) \# 即数据又k簇，每簇的中心点由数据的特征数决定  
\# 计算聚类中心  
for i in range(k):  
\# 获取数据中类别为i的数据索引  
indices = np.where(idx == i)  
\# 计算新的中心点  
if (len(indices\[0\])==0):  
break  
centroids\[i\] = (np.sum(X\[indices\[0\]\], axis=0) / len(indices\[0\])).ravel()  
return centroids

def runKmeans(X, initial\_centroids, max\_iters):  
m = X.shape  
k = initial\_centroids.shape\[0\]  
idx = np.zeros(m\[0\])  
centroids = initial\_centroids  
\# STEP2：实施聚类算法，调用之前的两个函数  
\# your code here (appro ~ 2 lines)  
for i in range(max\_iters):  
idx = findCloset(X, centroids)  
centroids = setNewCenter(X, idx, k)

return idx, centroids

def setCenters(X, k):  
m = X.shape \# 获取数据数量及特征数  
\# 根据数据信息以及簇个数构建各簇中心点  
centroids = np.zeros((k))  
\# 在数据中随机找k个点作为簇中心点  
idx = np.random.randint(0, m\[0\], k)

for i in range(k):
        centroids[i] = X[idx[i]]
    
    return centroids

A = hidden  
X = np.reshape(A,(A.shape\[0\] \* A.shape\[1\],1))

# 随机初始化聚类中心 #

initial\_centroids = setCenters(X, 4) \# 随机抽取2个样本点作为聚类中心

# 运行kmeans聚类算法，迭代10次 #

idx, centroids = runKmeans(X, initial\_centroids, 10)

# 获取样本点属于类别 #

idx = findCloset(X, centroids)

# 把每一个像素值与聚类结果进行匹配 #

X\_recovered = centroids\[idx.astype(int)\]  
X\_recovered.shape  
plt.subplot(143)  
plt.title(“Middle layer after Kmeans”)  
plt.imshow(X\_recovered.T.reshape(20,20))  
with tf.Session() as sess:  
tf.global\_variables\_initializer().run()  
saver = tf.train.Saver()  
saver.restore(sess, “outmodel/out\_model”)  
X\_recovered = X\_recovered.reshape(hidden2\_n,-1).T  
decode\_img=sess.run(\[img\_decode\],feed\_dict=\{a2:X\_recovered\})

print(decode_img[0].shape)

# xt = pixel.reshape(16384,3).T #

outImg = decode\_img\[0\].T.reshape(128,128,3)  
plt.subplot(144)  
plt.title(“Output Img”)  
plt.imshow(outImg)  
\#outImg = outImg\*255  
\#compress\_img = Image.fromarray(np.float32(outImg)).convert(‘RGB’) \# 将数组转化回图片  
\#compress\_img.save(“compress.bmp”) \# 将数组保存为图片

def psnr(origimal\_img, filtered\_img):  
if origimal\_img.shape != filtered\_img.shape:  
raise ValueError(“the shapes of img1 and img2 are not same.”)  
img1 = origimal\_img \# 转到0-255  
img2 = filtered\_img \# 转到0-255  
m, n = img1.shape  
mse = np.sum((img1 - img2)\*\*2) / (m \* n) \# 计算MSE  
return 20 \* np.log10(np.max(img1) / np.sqrt(mse)) \# 计算PSNR

def ssim(y\_true , y\_pred):  
u\_true = np.mean(y\_true)  
u\_pred = np.mean(y\_pred)  
var\_true = np.var(y\_true)  
var\_pred = np.var(y\_pred)  
std\_true = np.sqrt(var\_true)  
std\_pred = np.sqrt(var\_pred)  
c1 = np.square(0.01*7)  
c2 = np.square(0.03*7)  
ssim = (2 \* u\_true \* u\_pred + c1) \* (2 \* std\_pred \* std\_true + c2)  
denom = (u\_true \*\* 2 + u\_pred \*\* 2 + c1) \* (var\_pred + var\_true + c2)  
return ssim / denom

sumpsnr = 0  
for i in range(3):  
sumpsnr += psnr(originImg\[:,:,i\],outImg\[:,:,i\])  
psnr = sumpsnr/3  
ssim = ssim(originImg,outImg)  
print(“encoder输入图像和decoder输出图像之间的峰值信噪比(PSNR)为:”+str(psnr))  
print(“encoder输入图像和decoder输出图像之间的结构相似性(SSIM)为:”+str(ssim))