PIV_4:自组织映射(self organized map)

2019-08-17 本文已影响0人闪电侠悟空

POD分解（降维）要求基是正交的，POD强调的也就是orthogonal. 多个基叠加重构原始数据。
SOM也是一种降维，强调的是状态变量之间的连续性。不再要求基之间的正交性，采用一个最合适的基来表达数据即可。当然也可以进行流场分析。觉得SOM名称高大上，文章中常常遇到，好奇心驱使我搞清楚。
文章《Machine Learning for Fluid Mechanics》中这么介绍POD和SOM的投影轨迹(Discrete principal curves)的
The linear PCA will provide as an approximationthe least squares straight line between the points whereas the SOM will map the points onto a curved line that better approximates the data.

1.SOM算法思想:

关于自组织映射(SOM),可以看做一层前向线性全连接网络，隐层为feature map, 也就完成了SOM中的M（映射）的理解。自组织是什么意思呢？就是相邻位置的响应需要有一致性，p1响应值很大，那么相邻的p2也应该有个不小的响应值，这就是空间自组织的“分子机制”。当然SOM是通过无监督的方法进行训练。

个人理解的SOM

有 $N$ 个样本（POD中叫snapshot），其中一个sample $x_n\in \mathbb{R}^D$ .
构建 $M$ 个投影基 $w_m\in \mathbb{R}^D$ . 每个投影基与二维状态平面上的一个状态点 $p_m$ 对应。
找到最大投影值对应的基 $\arg \max_m {<x_i,w_m>}$ ，也就在二维状态平面上找到了 $x_i$ 的状态点。
二维状态平面，状态点之间存在邻域关系。

基学习算法：

初始化 $w_m$ ；
给一个样本 $x_i$ ,找到对应的状态点 $p_m$ (也就是 $w_m$ 产生最大的内积)；
更新对应的 $w_m = w_m +\lambda (x_i-w_m)$ ；
邻域状态点也稍微更新下 $w_k = w_k +0.5*\lambda (x_i-w_k)$ , $k$ 点属于 $i$ 的关联邻域；
重复更新过程，直至收敛。

2.snapshot POD和SOM对流场principal curves分析的测试（python）

建立仿真流场
POD学习（SVD分解）
POD的状态轨迹绘制
SOM学习
SOM的状态轨迹绘制

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
sns.set()
%matplotlib inline

#- 合成100个时刻的流场
N = 32
x,y = np.meshgrid(np.linspace(0,1,N),np.linspace(0,1,N))
u,v = [],[] 
for t in range(100):
    T = 1+t/100.0
    u.append(np.cos(2*np.pi*x/T+np.pi/2)*np.cos(2*np.pi*y/T))
    v.append(np.sin(2*np.pi*x/T+np.pi/2)*np.sin(2*np.pi*y/T))

plt.figure(figsize=(12,12))
plt.quiver(u[0],v[0])
plt.title("T= 1")
plt.figure(figsize=(12,12))
plt.quiver(u[99],v[99])
plt.title("T=2")

<matplotlib.text.Text at 0x7f5c56669828>

output_2_1.png

output_2_2.png

#- 做POD分解
snapshot_u =  np.swapaxes(np.array(u).reshape(100,-1),0,1)
snapshot_v =  np.swapaxes(np.array(v).reshape(100,-1),0,1)
snapshot = np.concatenate((snapshot_u,snapshot_v),axis = 0)
print(snapshot.shape)
U,s,V =np.linalg.svd(snapshot) # SVD就实现了POD分解

#- 利用前2个模态的系数，画POD的空间轨迹
pod_t1,pod_t2 = [],[]
for i in range(100):
    snapshot_i = snapshot[:,i]
    pod_t1.append(np.dot(U[:,0],snapshot_i))
    pod_t2.append(np.dot(U[:,1],snapshot_i))

plt.plot(pod_t1,pod_t2,"-o")
plt.xlabel("1st POD modal")
plt.ylabel("2nd POD modal")
plt.title("principal curves(POD)") # 也不是直线呀，很规律的轨迹

(2048, 100)


<matplotlib.text.Text at 0x7f5c56448828>

output_3_2.png

#SOM 分解
# 采用10*10（100）个隐藏状态
Nx,Ny = 12,12
W = np.random.randn(2*N*N,Nx*Ny)
W_temp = np.copy(W)

labmda = 0.05
for epoch in range(2000): # SOM学习的挺慢的，需要较大的迭代次数
    if (epoch +1)%200==0:
        print("training : %d (epoch)"%(epoch+1)) 
    for x in snapshot.T:
        # 前向计算一波
        p = np.matmul(x.reshape(1,-1),W)
        # print(p.shape)
        
        # 找到最佳的特征点 与四个邻居
        p_star = np.argmax(p)
        i_star,j_star = p_star//Nx,p_star%Nx
        
        p_n = []
        i_star_1 = i_star-1 if i_star>0 else np.NaN
        p_n.append( i_star_1*Nx+j_star)
        j_star_1 = j_star-1 if j_star>0 else np.NaN
        p_n.append(i_star*Nx+j_star_1)
        i_star_2 = i_star+1 if i_star+1<Nx else np.NaN
        p_n.append( i_star_2*Nx+j_star)
        j_star_2 = j_star+1 if j_star+1<Ny else np.NaN
        p_n.append( i_star*Nx+j_star_2)
        
        #print(p_star,p_n[0],p_n[1],p_n[2],p_n[3])
        
        # 更新W参数
        W_temp[:,p_star] = W[:,p_star]+labmda *(x-W[:,p_star])
        for pn in p_n:
            if not np.isnan(pn):
                W_temp[:,pn] = W[:,pn]+0.95*labmda *(x-W[:,pn])  
    W = np.copy(W_temp)
                
# 也不知道学习的好坏，看看SOM的基算了
for i in range(0,100,20):
    plt.figure(figsize=(8,8))
    model_u,model_v = W[:N**2,i].reshape(N,N),W[N**2:,i].reshape(N,N)
    plt.quiver(model_u,model_v)
    plt.title("SOM basis")

training : 200 (epoch)
training : 400 (epoch)
training : 600 (epoch)
training : 800 (epoch)
training : 1000 (epoch)
training : 1200 (epoch)
training : 1400 (epoch)
training : 1600 (epoch)
training : 1800 (epoch)
training : 2000 (epoch)

output_4_1.png

output_4_2.png

output_4_3.png

output_4_4.png

output_4_5.png

# 看看SOM的轨迹吧
som_t1,som_t2 = [],[]
for i in range(100):
    snapshot_i = snapshot[:,i]
    p = np.matmul(snapshot_i.reshape(1,-1),W)
    p_star = np.argmax(p)
    i_star,j_star = p_star//Nx,p_star%Nx
    som_t1.append(i_star)
    som_t2.append(j_star)

plt.plot(som_t1,som_t2,"-o")
plt.xlabel("SOM x")
plt.ylabel("SOM y")
plt.title("principal curves(SOM)") # 也不是直线，也不是曲线，都他妈的是什么玩意儿，很不规律，啥也说明不了。

<matplotlib.text.Text at 0x7f5c5be670f0>

output_5_1.png

3.总结

直接感受，POD很好用，SOM不是那么好用。我确实将算法简化不少(训练中不调整邻域关系权重)，但不影响结论。
SOM是一种“无监督的学习算法”，那么就严重依赖训练的数据量，也依赖 $W$ 的初始化情况，还依赖训练的超参数配置（学习率，邻域选择等）。有时候SOM的某些状态基就根本没有得到更新。每次跑，SOM的principal curve结果都不一样，恐怖。
SOM的思想是可取的，也有很多改进点。比如度量函数除了内积，也可采用更加科学的余弦夹角；SOM的初始化，是否可预置潜在的流动模式分布；”分子自组织“的思想，扩展到“组织器官”的分工层面；等等想法仁智各见。
我对开头论文中提出的SOM具有xxx的优势，这种说话持怀疑态度。

4. 参考资料

https://www.cnblogs.com/surfzjy/p/7944454.html

PIV_4:自组织映射(self organized map)

1.SOM算法思想:

2.snapshot POD和SOM对流场principal curves分析的测试（python）

3.总结

4. 参考资料

猜你喜欢

热点阅读