自編碼器是一種無監督機器學習演算法，通過計算自編碼的輸出與原輸入的誤差，不斷調節自編碼器的引數，最終訓練出模型。自編碼器可以用於壓縮輸入資訊，提取有用的輸入特徵。如,[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]四位元資訊可以壓縮成兩位,[0,0],[1,0],[1,1],[0,1]。此時，自編碼器的中間層的神經元個數為2。但是，有時中間隱藏層的神經元個數可能超過輸出，此時需要通過稀疏因子調節代價函式，讓中間隱藏層的神經元資訊大部分接近於0但不為0.自編碼器具體推導詳見http://ufldl.stanford.edu/wiki/index.php/%E8%87%AA%E7%BC%96%E7%A0%81%E7%AE%97%E6%B3%95%E4%B8%8E%E7%A8%80%E7%96%8F%E6%80%A7。

以下是通過tensorflow實現的稀疏自編碼器。

1、初始化引數

input_nodes = 8*8 //輸入節點數
hidden_size = 100//隱藏節點數
output_nodes = 8*8//輸出節點數

2、初始化訓練集資料，從mat檔案中讀取影象塊，隨機生成10000個8*8的影象塊

def sampleImage():
    mat = scipy.io.loadmat('F:/ml/code/IMAGES.mat')
    pic = mat['IMAGES']
    shape = pic.shape
    patchsize = 8
    numpatches = 1000
    patches = []
    i = np.random.randint(0, shape[0]-patchsize,numpatches)
    j = np.random.randint(0, shape[1]-patchsize, numpatches)
    k = np.random.randint(0, shape[2], numpatches)


    for l in range(numpatches):
        temp = pic[i[l]:(i[l]+patchsize), j[l]:(j[l]+patchsize), k[l]]
        temp = temp.reshape(patchsize*patchsize)
        patches.append(temp)
    return patches

3、通過xvaier初始化第一層的權重值，xvaier初始化詳見http://blog.csdn.net/shuzfan/article/details/51338178

def xvaier_init(input_size, output_size):
    low = -np.sqrt(6.0/(input_nodes+output_nodes))
    high = -low
    return tf.random_uniform((input_size, output_size), low, high, dtype = tf.float32)

4、計算代價函式，代價函式由三部分組成，均方差項，權重衰減項，以及稀疏因子項

def computecost(w,b,x,w1,b1):
    p = 0.1
    beta = 3
    lamda = 0.00001
    
    hidden_output = tf.sigmoid(tf.matmul(x,w) + b)
    pj = tf.reduce_mean(hidden_output, 0)
    sparse_cost = tf.reduce_sum(p*tf.log(p/pj)+(1-p)*tf.log((1-p)/(1-pj)))
    output = tf.sigmoid(tf.matmul(hidden_output,w1)+b1)
    regular = lamda*(tf.reduce_sum(w*w)+tf.reduce_sum(w1*w1))/2
    cross_entropy = tf.reduce_mean(tf.pow(output - x, 2))/2 +sparse_cost*beta + regular #+ regular+sparse_cost*beta 
    return cross_entropy, hidden_output, output

5、視覺化自編碼器：為了使隱藏單元得到最大激勵（隱藏單元需要什麼樣的特徵輸入），將這些特徵輸入顯示出來。

def show_image(w):
    sum = np.sqrt(np.sum(w**2, 0))
    changedw = w/sum
    a,b = changedw.shape
    c = np.sqrt(a*b)
    d = int(np.sqrt(a))
    e = int(c/d)
    buf = 1
    newimage = -np.ones((buf+(d+buf)*e,buf+(d+buf)*e))
    k = 0
    for i in range(e):
        for j in range(e):
            maxvalue = np.amax(changedw[:,k])
            if(maxvalue<0):
                maxvalue = -maxvalue
            newimage[(buf+i*(d+buf)):(buf+i*(d+buf)+d),(buf+j*(d+buf)):(buf+j*(d+buf)+d)] = np.reshape(changedw[:,k],(d,d))/maxvalue
            k+=1
    
    plt.figure("beauty")
    plt.imshow(newimage)
    plt.axis('off')
    plt.show()   

6、主函式，通過AdamOptimizer下降誤差，調節引數

def main():
    w = tf.Variable(xvaier_init(input_nodes, hidden_size))
    b = tf.Variable(tf.truncated_normal([hidden_size],0.1))   
    x = tf.placeholder(tf.float32, shape = [None, input_nodes])
    w1 = tf.Variable(tf.truncated_normal([hidden_size,input_nodes], -0.1, 0.1))
    b1 = tf.Variable(tf.truncated_normal([output_nodes],0.1))


    cost, hidden_output, output = computecost(w,b,x,w1,b1)
    train_step = tf.train.AdamOptimizer().minimize(cost)
    train_x = sampleImage()
    sess = tf.Session()
    sess.run(tf.global_variables_initializer())
    
    for i in range(100000):
        _,hidden_output_, output_,cost_,w_= sess.run([train_step, hidden_output, output,cost,w], feed_dict = {x : train_x})
        if i%1000 == 0:
            print(hidden_output_)
            print(output_)
            print(cost_)
    np.save("weights1.npy", w_)
    show_image(w_)

        本次實驗過程中，除了整體思想，最難的還是調節引數。使用稀疏因子加入代價函式，個人覺得隱藏層的神經元數要多於輸入層，結果才比較理想。希望大家多多指教。

程式碼地址：https://github.com/summersunshine1/datamining/tree/master/sparseencoder