「Python 数据处理基础」数据的降维以及Scikit-learn实现的14种方式

小灰灰 2022-10-12 12:10 7阅读 0赞

### 文章目录 ###

*  内容介绍
 *  数据降维
 *   *  sklearn.decomposition.DictionaryLearning
     *  FactorAnalysis
     *  FastICA
     *  IncrementalPCA
     *  KernelPCA
     *  LatentDirichletAllocation
     *  MiniBatchDictionaryLearning
     *  MiniBatchSparsePCA
     *  NMF
     *  PCA
     *  SparsePCA
     *  SparseCoder
     *  TruncatedSVD
     *  non\_negative\_factorization

# 内容介绍 #

将日常工作中遇到的数据降维的方法进行总结，其中主要包括 **方法和算法** 等处理方式思路，并且长期更新。

# 数据降维 #

数据降维是为了减少数据的维数，俗称减少字段数（数据字段过多时候可以使用）。可以减少模型计算量和模型运行时间，减少噪声变量信息对模型结果的影响，并有助于可视化降维信息并减少数据存储空间。

**一般降维方法：线性降维和非线性降维**

*  **经验方法**：基于经验，从许多维度特征中选择对结果影响更大的特征（字段）。
 *  **测量算法**：通过对多个维度进行连续测试，选择计算，获取最佳特征（字段）。
 *  **统计分析法**：通过相关性分析或通过计算不同维度之间的互信息量获取。
 *  **机器学习法**：通过机器学习算法获取特征值或不同特征的权重选择重要的特征。

**常用的代表性算法举例**

*  **ICA**（独立成分分析）、**PCA**（主成分分析）
 *  **FA**（因子分析）
 *  **LDA** （线性判别分析）
 *  **LLE**（局部线性嵌入）
 *  **Kernel PCA**（内核主成分分析）

## sklearn.decomposition.DictionaryLearning ##

import numpy as np
    from sklearn.datasets import make_sparse_coded_signal
    from sklearn.decomposition import DictionaryLearning
    X, dictionary, code = make_sparse_coded_signal(
        n_samples=100, n_components=15, n_features=20, n_nonzero_coefs=10,
        random_state=42,
    )
    dict_learner = DictionaryLearning(
        n_components=15, transform_algorithm='lasso_lars', random_state=42,
    )
    X_transformed = dict_learner.fit_transform(X)
    
    np.mean(X_transformed == 0)

0.8833333333333333

## FactorAnalysis ##

from sklearn.datasets import load_digits
    from sklearn.decomposition import FactorAnalysis
    X, _ = load_digits(return_X_y=True)
    transformer = FactorAnalysis(n_components=7, random_state=0)
    X_transformed = transformer.fit_transform(X)
    X_transformed.shape

(1797, 7)

## FastICA ##

from sklearn.datasets import load_digits
    from sklearn.decomposition import FastICA
    X, _ = load_digits(return_X_y=True)
    transformer = FastICA(n_components=7,
            random_state=0)
    X_transformed = transformer.fit_transform(X)
    X_transformed.shape

d:\MyTools\Anaconda3_5.2.0\lib\site-packages\sklearn\decomposition\_fastica.py:120: ConvergenceWarning: FastICA did not converge. Consider increasing tolerance or the maximum number of iterations.
      ConvergenceWarning)
    
    
    
    
    
    (1797, 7)

## IncrementalPCA ##

from sklearn.datasets import load_digits
    from sklearn.decomposition import IncrementalPCA
    from scipy import sparse
    X, _ = load_digits(return_X_y=True)
    transformer = IncrementalPCA(n_components=7, batch_size=200)
    # either partially fit on smaller batches of data
    transformer.partial_fit(X[:100, :])
    
    # or let the fit function itself divide the data into batches
    X_sparse = sparse.csr_matrix(X)
    X_transformed = transformer.fit_transform(X_sparse)
    X_transformed.shape

(1797, 7)

## KernelPCA ##

from sklearn.datasets import load_digits
    from sklearn.decomposition import KernelPCA
    X, _ = load_digits(return_X_y=True)
    transformer = KernelPCA(n_components=7, kernel='linear')
    X_transformed = transformer.fit_transform(X)
    X_transformed.shape

(1797, 7)

## LatentDirichletAllocation ##

from sklearn.decomposition import LatentDirichletAllocation
    from sklearn.datasets import make_multilabel_classification
    # This produces a feature matrix of token counts, similar to what
    # CountVectorizer would produce on text.
    X, _ = make_multilabel_classification(random_state=0)
    lda = LatentDirichletAllocation(n_components=5,
        random_state=0)
    lda.fit(X)
    
    # get topics for some given samples:
    lda.transform(X[-2:])

array([[0.00360392, 0.25499205, 0.0036211 , 0.64236448, 0.09541846],
           [0.15297572, 0.00362644, 0.44412786, 0.39568399, 0.003586  ]])

## MiniBatchDictionaryLearning ##

import numpy as np
    from sklearn.datasets import make_sparse_coded_signal
    from sklearn.decomposition import MiniBatchDictionaryLearning
    X, dictionary, code = make_sparse_coded_signal(
        n_samples=100, n_components=15, n_features=20, n_nonzero_coefs=10,
        random_state=42)
    dict_learner = MiniBatchDictionaryLearning(
        n_components=15, transform_algorithm='lasso_lars', random_state=42,
    )
    X_transformed = dict_learner.fit_transform(X)
    
    np.mean(X_transformed == 0)

0.8733333333333333

## MiniBatchSparsePCA ##

import numpy as np
    from sklearn.datasets import make_friedman1
    from sklearn.decomposition import MiniBatchSparsePCA
    X, _ = make_friedman1(n_samples=200, n_features=30, random_state=0)
    transformer = MiniBatchSparsePCA(n_components=5, batch_size=50,
                                     random_state=0)
    transformer.fit(X)
    
    X_transformed = transformer.transform(X)
    X_transformed.shape
    
    # most values in the components_ are zero (sparsity)
    np.mean(transformer.components_ == 0)

0.94

## NMF ##

import numpy as np
    X = np.array([[1, 1], [2, 1], [3, 1.2], [4, 1], [5, 0.8], [6, 1]])
    from sklearn.decomposition import NMF
    model = NMF(n_components=2, init='random', random_state=0)
    W = model.fit_transform(X)
    H = model.components_
    H

array([[2.09783018, 0.30560234],
           [2.13443044, 2.13171694]])

## PCA ##

import numpy as np
    from sklearn.decomposition import PCA
    X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
    pca = PCA(n_components=2)
    pca.fit(X)
    
    print(pca.explained_variance_ratio_)
    
    print(pca.singular_values_)

[0.99244289 0.00755711]
    [6.30061232 0.54980396]

## SparsePCA ##

import numpy as np
    from sklearn.datasets import make_friedman1
    from sklearn.decomposition import SparsePCA
    X, _ = make_friedman1(n_samples=200, n_features=30, random_state=0)
    transformer = SparsePCA(n_components=5, random_state=0)
    transformer.fit(X)
    
    X_transformed = transformer.transform(X)
    X_transformed.shape
    
    # most values in the components_ are zero (sparsity)
    np.mean(transformer.components_ == 0)

0.9666666666666667

## SparseCoder ##

import numpy as np
    from sklearn.decomposition import SparseCoder
    X = np.array([[-1, -1, -1], [0, 0, 3]])
    dictionary = np.array(
        [[0, 1, 0],
         [-1, -1, 2],
         [1, 1, 1],
         [0, 1, 1],
         [0, 2, 1]],
       dtype=np.float64
    )
    coder = SparseCoder(
        dictionary=dictionary, transform_algorithm='lasso_lars',
        transform_alpha=1e-10,
    )
    coder.transform(X)

array([[ 0.,  0., -1.,  0.,  0.],
           [ 0.,  1.,  1.,  0.,  0.]])

## TruncatedSVD ##

from sklearn.decomposition import TruncatedSVD
    from scipy.sparse import random as sparse_random
    X = sparse_random(100, 100, density=0.01, format='csr',
                      random_state=42)
    svd = TruncatedSVD(n_components=5, n_iter=7, random_state=42)
    svd.fit(X)
    
    print(svd.explained_variance_ratio_)
    
    print(svd.explained_variance_ratio_.sum())
    
    print(svd.singular_values_)

[0.0646051  0.06339479 0.06394407 0.05352903 0.04062679]
    0.2860997781448579
    [1.55360944 1.5121377  1.51052009 1.37056529 1.19917045]

## non\_negative\_factorization ##

import numpy as np
    X = np.array([[1,1], [2, 1], [3, 1.2], [4, 1], [5, 0.8], [6, 1]])
    from sklearn.decomposition import non_negative_factorization
    W, H, n_iter = non_negative_factorization(X, n_components=2,
    init='random', random_state=0)
    W

array([[0.        , 0.46880684],
           [0.55699523, 0.3894146 ],
           [1.00331638, 0.41925352],
           [1.6733999 , 0.22926926],
           [2.34349311, 0.03927954],
           [2.78981512, 0.06911798]])