来源于 Unsupervised Learning in Python 学习笔记 - A Hugo website ， 要改一起改。
Non-negative matrix factorization (NMF) | Python
interpretable 真的PCA，看不懂啊。完全是梦幻走步，瞎给idea啊。 但是，NMF必须都要非负啊，啊啊啊啊。
最后的NMF特征，可以看成是原特征的线形相加。
$$\tilde x = \beta_1 x_1 + \beta_2 x_2 + beta_3 x_3$$ 其中，$x, x_1, x_2, x_3$都是向量。
fit() / transform()都可以用。
NumPy arrays and with csr_matrix都可以用。
NMF(n_components=2)设定好，和主成分分析很像。
from sklearn.decomposition import NMF引入。
model = NMF(n_components=2)设定好特征变量数量。
model.fit(samples)跑模型。
nmf_features = model.transform(samples)矩阵转置成功。
$$NMF特征变量行数 = 原样本行数$$
但是我还是没弄懂怎么个相乘方法。
NMF applied to Wikipedia articles | Python
# Import NMF
from sklearn.decomposition import NMF
# Create an NMF instance: model
model = NMF(n_components = 6)
# Fit the model to articles
model.fit(articles)
# Transform the articles: nmf_features
nmf_features = model.transform(articles)
# Print the NMF features
print(nmf_features)
NMF features of the Wikipedia articles | Python
# Import pandas
import pandas as pd
# Create a pandas DataFrame: df
df = pd.DataFrame(nmf_features, index=titles)
# Print the row for 'Anne Hathaway'
print(df.loc['Anne Hathaway'])
# Print the row for 'Denzel Washington'
print(df.loc['Denzel Washington'])
In [2]: print(df.loc['Denzel Washington'])
0 0.000000
1 0.005601
2 0.000000
3 0.422380
4 0.000000
5 0.000000
Name: Denzel Washington, dtype: float64
In [3]: print(df.loc['Denzel Washington'])
0 0.000000
1 0.005601
2 0.000000
3 0.422380
4 0.000000
5 0.000000
Name: Denzel Washington, dtype: float64
第三个特征非常屌啊。
终于看懂了。哈哈。
$$S_{m \times n} = F_{m \times \hat n} \times C_{\hat n \times n}$$
其中 原样本是$S$，二维矩阵，$m$表示ID数，$n$表示特征变量数， 原样本是$F$，二维矩阵，$m$表示ID数，$\hat n$表示NMF特征变量数，这是降维、变密集的结果，其中$\hat n \leq n$， 原样本是$C$，二维矩阵，$\hat n$表示NMF特征变量数，$n$表示特征变量数。
其中 $S_{m \times n}$是高维度的、容易过拟合的，且稀疏、容易不显著的。 $F_{m \times \hat n}$是低维度的、不容易过拟合的，且密集、容易显著的。
$$\hat n \leq n \to \hat n + noise = n$$
因此我们的假设认为，我们的降维是剔除了噪音的。噪音是过拟合的本质，因此NMF剔除了噪音，因此避免了过拟合。
为了方便理解，做一个简单的计算。
假设原样本的某一行$[0.12, 0.18, 0.32, 0.14]$， 表示某个用户的四个特征。 产生$S_{1 \times 4}$， 假设NMF特征向量$F_{1 \times 2}$计算结果为$[0.15, 0.12]$，表示用户的两个NMF特征。 假设NMF权重$C_{2 \times 4}$为 $$\begin{bmatrix} 0.01 & 0 & 2.13 & 0.54 \ 0.99 & 1.47 & 0 & 0.5 \ \end{bmatrix}$$
所以结果满足
$$ \begin{align} [0.15, 0.12] \times \begin{bmatrix} 0.01 & 0 & 2.13 & 0.54 \ 0.99 & 1.47 & 0 & 0.5 \ \end{bmatrix} & = [0.1203,0.1764,0.3195,0.141 ] \ & = [0.12, 0.18, 0.32, 0.14] \ F_{1 \times 2} \times C_{2 \times 4} & = S_{1 \times 4} \ \end{align} $$
这里的优势在于：
相当于逻辑回归的模块化， 针对每一个用户的$C_{2 \times 4}$都是不一样的， 因此可以做到每个用户的精细化转化变量。
相当于主成分分析， 针对每一个用户的$C_{2 \times 4}$都是都反映了$F_{1 \times 2}$中不同变量的权重， 因此转化结果可以给业务部门解释。
$$C_{2 \times 4} = \begin{bmatrix} V_1 & V_2 & V_3 & V_4 \ w_{11} & w_{12} & w_{13} & w_{14} \ w_{21} & w_{22} & w_{23} & w_{24} \ \end{bmatrix}$$
其中$w_{ij}$衡量了某用户第$j$个原始变量在第$i$个NMF变量中的权重。 对于每个NMF变量，我们都可以做个排序，看看哪个原始变量最强！ 因此NMF权重矩阵，衡量我们变量优良中差顺序。
NMF learns interpretable parts | Python
没有看懂这个地方图片能干嘛！！！
# Import pandas
import pandas as pd
# Create a DataFrame: components_df
components_df = pd.DataFrame(model.components_,columns=words)
# Print the shape of the DataFrame
print(components_df.shape)
# Select row 3: component
component = components_df.iloc[3]
# Print result of nlargest
print(component.nlargest())
<script.py> output:
(6, 13125)
film 0.627877
award 0.253131
starred 0.245284
role 0.211451
actress 0.186398
Name: 3, dtype: float64
Explore the LED digits dataset | Python
# Import pyplot
from matplotlib import pyplot as plt
# Select the 0th row: digit
digit = samples[0]
# Print digit
print(digit)
# Reshape digit to a 13x8 array: bitmap
bitmap = digit.reshape(13,8)
# Print bitmap
print(bitmap)
# Use plt.imshow to display bitmap
plt.imshow(bitmap, cmap='gray', interpolation='nearest')
plt.colorbar()
plt.show()
In [16]: print(bitmap)
[[ 0. 0. 0. 0. 0. 0. 0. 0.]
[ 0. 0. 1. 1. 1. 1. 0. 0.]
[ 0. 0. 0. 0. 0. 0. 1. 0.]
[ 0. 0. 0. 0. 0. 0. 1. 0.]
[ 0. 0. 0. 0. 0. 0. 1. 0.]
[ 0. 0. 0. 0. 0. 0. 1. 0.]
[ 0. 0. 0. 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0. 0. 1. 0.]
[ 0. 0. 0. 0. 0. 0. 1. 0.]
[ 0. 0. 0. 0. 0. 0. 1. 0.]
[ 0. 0. 0. 0. 0. 0. 1. 0.]
[ 0. 0. 0. 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0. 0. 0. 0.]]
这就是稀疏矩阵。