Python語言的機器學習工具
Scikit-learn包括許多知名的機器學習演算法的實現(演算法原理一定要懂)
Scikit-learn文件完善，容易上手，豐富的API，使其在學術界頗受歡迎。

一、特徵抽取 (使用scikit-learn進行資料的特徵抽取)

1、字典型別資料----特徵抽取

使用類：sklearn.feature_extraction.DictVectorizer

sklearn.feature_extraction.DictVectorizer的作用：對字典資料進行特徵值化。即：把字典裡的一些非數值型的資料分別轉換為特徵，然後用特徵值(0或1)來表示該特徵是否存在。待輸入的資料要求為字典型別，如果原始資料不是字典型別，而是陣列形式，需要將有類別的這些特徵先要轉換為字典資料，如果某些特徵用不到，則不用提取(比如下圖中的name，如果用不到，就不用提取出來)。

DictVectorizer語法：

• DictVectorizer(sparse=True,…)，例項化
• DictVectorizer.fit_transform(X) ，X:字典或者包含字典的迭代器；返回值：返回sparse矩陣
• DictVectorizer.inverse_transform(X)，X:array陣列或者sparse矩陣；返回值:轉換之前資料格式
• DictVectorizer.get_feature_names()，返回類別名稱
• DictVectorizer.transform(X)，按照原先的標準轉換

字典特徵抽取流程：

1. 例項化類DictVectorizer
2. 呼叫fit_transform方法輸入資料並轉換 (注意返回格式)

[{'city': '北京','temperature':100}
{'city': '上海','temperature':60}
{'city': '深圳','temperature':30}]

# 字典特徵抽取
from sklearn.feature_extraction import DictVectorizer

def dictvec():
    """字典資料抽取"""
    # 例項化
    my_dict00 = DictVectorizer()  # 預設值為sparse=True，返回sparse矩陣
    # 呼叫fit_transform對字典格式的原始資料進行轉換，預設返回sparse矩陣
    my_data00 = my_dict00.fit_transform([{'city': '北京', 'temperature': 100}, {'city': '上海', 'temperature': 60}, {'city': '深圳', 'temperature': 30}])
    print('轉換後的特徵值(sparse矩陣型別)：my_data00=\n', my_data00)
    my_dict = DictVectorizer(sparse=False)  # sparse=False 返回矩陣
    # 呼叫fit_transform對字典格式的原始資料進行轉換，通過DictVectorizer(sparse=False)設定返回型別為矩陣(ndarray型別)，而不是預設的sparse矩陣
    my_data01 = my_dict.fit_transform([{'city': '北京', 'temperature': 100}, {'city': '上海', 'temperature': 60}, {'city': '深圳', 'temperature': 30}])
    # 獲取類別名稱
    feature_names = my_dict.get_feature_names()
    # 呼叫inverse_transform，返回轉換之前資料格式
    my_data02 = my_dict.inverse_transform(my_data01)
    print('特徵值列名：feature_names = my_dict.get_feature_names()=\n', feature_names)
    print('轉換後的特徵值(ndarray矩陣型別)：my_data01=\n', my_data01)
    print('my_data01.shape=', my_data01.shape)
    print('my_data02 = my_dict.inverse_transform(my_data01)=\n', my_data02)
    return None


if __name__ == "__main__":
    dictvec()

列印結果：

轉換後的特徵值(sparse矩陣型別)：my_data00=
   (0, 1)	1.0
  (0, 3)	100.0
  (1, 0)	1.0
  (1, 3)	60.0
  (2, 2)	1.0
  (2, 3)	30.0
特徵值列名：feature_names = my_dict.get_feature_names()=
 ['city=上海', 'city=北京', 'city=深圳', 'temperature']
轉換後的特徵值(ndarray矩陣型別)：my_data01=
 [[  0.   1.   0. 100.]
 [  1.   0.   0.  60.]
 [  0.   0.   1.  30.]]
my_data01.shape= (3, 4)
my_data02 = my_dict.inverse_transform(my_data01)=
 [{'city=北京': 1.0, 'temperature': 100.0}, {'city=上海': 1.0, 'temperature': 60.0}, {'city=深圳': 1.0, 'temperature': 30.0}]

2、文字型別資料----特徵抽取

2.1 方式一(抽取詞頻)：sklearn.feature_extraction.text.CountVectorizer

sklearn.feature_extraction.text.CountVectorizer的作用：對文字資料進行特徵值化。首先將所有文章裡的所有的詞統計出來，重複的只統計一次。然後對每篇文章，在詞的列表裡面進行統計每個詞出現的次數。注意：單個字母不統計(因為單個單詞沒有單詞分類依據)。

DictVectorizer語法：

• CountVectorizer(max_df=1.0,min_df=1,…)----例項化，返回詞頻矩陣
• CountVectorizer.fit_transform(X,y)----X:文字或者包含文字字串的可迭代物件；返回值：返回sparse矩陣
• CountVectorizer.inverse_transform(X)----X:array陣列或者sparse矩陣；返回值:轉換之前資料格式
• CountVectorizer.get_feature_names()----返回值:單詞列表

文字特徵抽取流程：

1. 例項化類CountVectorizer
2. 呼叫fit_transform方法輸入資料並轉換(注意返回格式，利用toarray()進行sparse矩陣轉換array陣列)
3. 中文需要先進行分詞，然後再進行特徵抽取。

2.1.1 不帶有中文的文字特徵抽取

["life is short,i like python","life is too long,i dislike python"]

# 文字特徵抽取
from sklearn.feature_extraction.text import CountVectorizer

def countvec():
    """對文字進行特徵值化"""
    cv = CountVectorizer()
    data = cv.fit_transform(["Python: life is short,i like python. it is python.", "life is too long,i dislike python. it is not python."])  # 列表裡表示第一篇文章，第二篇文章
    print('cv.get_feature_names() = \n', cv.get_feature_names())
    print('data = \n', data)
    print('data.toarray() = \n', data.toarray())
    return None


if __name__ == "__main__":
    countvec()

列印結果：

cv.get_feature_names() = 
 ['dislike', 'is', 'it', 'life', 'like', 'long', 'not', 'python', 'short', 'too']
data = 
   (0, 2)	1
  (0, 4)	1
  (0, 8)	1
  (0, 1)	2
  (0, 3)	1
  (0, 7)	3
  (1, 6)	1
  (1, 0)	1
  (1, 5)	1
  (1, 9)	1
  (1, 2)	1
  (1, 1)	2
  (1, 3)	1
  (1, 7)	2
data.toarray() = 
 [[0 2 1 1 1 0 0 3 1 0]
 [1 2 1 1 0 1 1 2 0 1]]

2.1.2 帶有中文的文字特徵抽取(不進行分詞)

有中文的文字特徵抽取，如果不先進行中文分詞，則將一段話當做一個詞

["你們感覺人生苦短，你 喜歡python java javascript", "人生 漫長，我們 不喜歡python,react"]

# 文字特徵抽取
from sklearn.feature_extraction.text import CountVectorizer

def countvec():
    """對文字進行特徵值化"""
    cv = CountVectorizer()
    data = cv.fit_transform(["你們感覺人生苦短，你 喜歡python java javascript", "人生 漫長，我們 不喜歡python,react"])  # 列表裡表示第一篇文章，第二篇文章
    print('cv.get_feature_names() = \n', cv.get_feature_names())
    print('data = \n', data)
    print('data.toarray() = \n', data.toarray())
    return None


if __name__ == "__main__":
    countvec()

列印結果：

cv.get_feature_names() = 
 ['java', 'javascript', 'react', '不喜歡python', '人生', '你們感覺人生苦短', '喜歡python', '我們', '漫長']
data = 
   (0, 1)	1
  (0, 0)	1
  (0, 6)	1
  (0, 5)	1
  (1, 2)	1
  (1, 3)	1
  (1, 7)	1
  (1, 8)	1
  (1, 4)	1
data.toarray() = 
 [[1 1 0 0 0 1 1 0 0]
 [0 0 1 1 1 0 0 1 1]]

2.1.3 使用“jieba”庫進行中文分詞的文字特徵抽取

安裝：pip3 install jieba
使用：jieba.cut("我是一個好程式設計師")
返回值：詞語生成器

# 文字特徵抽取
from sklearn.feature_extraction.text import CountVectorizer
import jieba

def cutword():
    """中文分詞"""
    con1 = jieba.cut("今天很殘酷，明天更殘酷，後天很美好，但絕對大部分是死在明天晚上，所以每個人不要放棄今天。")
    con2 = jieba.cut("我們看到的從很遠星系來的光是在幾百萬年之前發出的，這樣當我們看到宇宙時，我們是在看它的過去。")
    con3 = jieba.cut("如果只用一種方式瞭解某樣事物，你就不會真正瞭解它。瞭解事物真正含義的祕密取決於如何將其與我們所瞭解的事物相聯絡。")
    # 轉換成列表
    content1 = list(con1)
    content2 = list(con2)
    content3 = list(con3)
    # 把列表轉換成字串
    c1 = ' '.join(content1)
    c2 = ' '.join(content2)
    c3 = ' '.join(content3)
    return c1, c2, c3


def hanzivec():
    """中文特徵值化"""
    c1, c2, c3 = cutword()
    print('c1 = \n', c1)
    print('c2 = \n', c2)
    print('c3 = \n', c3)
    cv = CountVectorizer()
    data = cv.fit_transform([c1, c2, c3])
    print('cv.get_feature_names() = \n', cv.get_feature_names())  # 單個詞不統計
    print('data.toarray() = \n', data.toarray())

    return None


if __name__ == "__main__":
    hanzivec()

列印結果：

c1 = 
 今天 很 殘酷 ， 明天 更 殘酷 ， 後天 很 美好 ， 但 絕對 大部分 是 死 在 明天 晚上 ， 所以 每個 人 不要 放棄 今天 。
c2 = 
 我們 看到 的 從 很 遠 星系 來 的 光是在 幾百萬年 之前 發出 的 ， 這樣 當 我們 看到 宇宙 時 ， 我們 是 在 看 它 的 過去 。
c3 = 
 如果 只用 一種 方式 瞭解 某樣 事物 ， 你 就 不會 真正 瞭解 它 。 瞭解 事物 真正 含義 的 祕密 取決於 如何 將 其 與 我們 所 瞭解 的 事物 相 聯絡 。
cv.get_feature_names() = 
 ['一種', '不會', '不要', '之前', '瞭解', '事物', '今天', '光是在', '幾百萬年', '發出', '取決於', '只用', '後天', '含義', '大部分', '如何', '如果', '宇宙', '我們', '所以', '放棄', '方式', '明天', '星系', '晚上', '某樣', '殘酷', '每個', '看到', '真正', '祕密', '絕對', '美好', '聯絡', '過去', '這樣']
data.toarray() = 
 [[0 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 0]
 [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 1]
 [1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0]]

2.2 方式二(tf-idf抽取重要性)：sklearn.feature_extraction.text.TfidfVectorizer

tf：term frequency---->詞頻
idf：inverse document frequency---->逆文件頻率=log($\frac{總文檔數量}{該詞出現的文檔數量}$)
tf × idf---->該詞在該篇文件中的重要性程度
tf-idf的主要思想是：如果某個詞或短語在一篇文章中出現的概率高，並且在其他文章中很少出現，則認為此詞或者短語具有很好的類別區分能力，適合用來分類。
tf-idf作用：用以評估一字詞對於一個檔案集或一個語料庫中的其中一份檔案的重要程度。
tf-idf是分類機器學習演算法的重要依據。
tf-idf方法比count方法更好一些，但是在自然語言處理過程中會使用比tf-idf更好的方法。

# 文字特徵抽取(tf-idf方式)
from sklearn.feature_extraction.text import TfidfVectorizer
import jieba

def cutword():
    """中文分詞"""
    con1 = jieba.cut("今天很殘酷，明天更殘酷，後天很美好，但絕對大部分是死在明天晚上，所以每個人不要放棄今天。")
    con2 = jieba.cut("我們看到的從很遠星系來的光是在幾百萬年之前發出的，這樣當我們看到宇宙時，我們是在看它的過去。")
    con3 = jieba.cut("如果只用一種方式瞭解某樣事物，你就不會真正瞭解它。瞭解事物真正含義的祕密取決於如何將其與我們所瞭解的事物相聯絡。")
    # 轉換成列表
    content1 = list(con1)
    content2 = list(con2)
    content3 = list(con3)
    # 把列表轉換成字串
    c1 = ' '.join(content1)
    c2 = ' '.join(content2)
    c3 = ' '.join(content3)
    return c1, c2, c3


def tfidfvec():
    """中文特徵值化"""
    c1, c2, c3 = cutword()
    print('c1 = \n', c1)
    print('c2 = \n', c2)
    print('c3 = \n', c3)
    tf = TfidfVectorizer()
    data = tf.fit_transform([c1, c2, c3])
    print('tf.get_feature_names() = \n', tf.get_feature_names())
    print('data.toarray() = \n', data.toarray())

    return None


if __name__ == "__main__":
    tfidfvec()

列印結果：

c1 = 
 今天 很 殘酷 ， 明天 更 殘酷 ， 後天 很 美好 ， 但 絕對 大部分 是 死 在 明天 晚上 ， 所以 每個 人 不要 放棄 今天 。
c2 = 
 我們 看到 的 從 很 遠 星系 來 的 光是在 幾百萬年 之前 發出 的 ， 這樣 當 我們 看到 宇宙 時 ， 我們 是 在 看 它 的 過去 。
c3 = 
 如果 只用 一種 方式 瞭解 某樣 事物 ， 你 就 不會 真正 瞭解 它 。 瞭解 事物 真正 含義 的 祕密 取決於 如何 將 其 與 我們 所 瞭解 的 事物 相 聯絡 。
tf.get_feature_names() = 
 ['一種', '不會', '不要', '之前', '瞭解', '事物', '今天', '光是在', '幾百萬年', '發出', '取決於', '只用', '後天', '含義', '大部分', '如何', '如果', '宇宙', '我們', '所以', '放棄', '方式', '明天', '星系', '晚上', '某樣', '殘酷', '每個', '看到', '真正', '祕密', '絕對', '美好', '聯絡', '過去', '這樣']
data.toarray() = 
 [[0.         0.         0.21821789 0.         0.         0.
  0.43643578 0.         0.         0.         0.         0.
  0.21821789 0.         0.21821789 0.         0.         0.
  0.         0.21821789 0.21821789 0.         0.43643578 0.
  0.21821789 0.         0.43643578 0.21821789 0.         0.
  0.         0.21821789 0.21821789 0.         0.         0.        ]
 [0.         0.         0.         0.2410822  0.         0.
  0.         0.2410822  0.2410822  0.2410822  0.         0.
  0.         0.         0.         0.         0.         0.2410822
  0.55004769 0.         0.         0.         0.         0.2410822
  0.         0.         0.         0.         0.48216441 0.
  0.         0.         0.         0.         0.2410822  0.2410822 ]
 [0.15698297 0.15698297 0.         0.         0.62793188 0.47094891
  0.         0.         0.         0.         0.15698297 0.15698297
  0.         0.15698297 0.         0.15698297 0.15698297 0.
  0.1193896  0.         0.         0.15698297 0.         0.
  0.         0.15698297 0.         0.         0.         0.31396594
  0.15698297 0.         0.         0.15698297 0.         0.        ]]

二、特徵的預處理(對資料進行處理)

特徵的預處理：通過特定的統計方法（數學方法）將資料轉換成演算法要求的資料。
數值型資料預處理方法(縮放)：1、歸一化；2、標準化；3、缺失值；並不是每個演算法都需要縮放處理。
類別型資料預處理方法：one-hot編碼；
時間型資料預處理方法：時間的切分；
scikit-learn所有的預處理方法都在sklearn. preprocessing類下

1、歸一化方法(不常用)

1.1 歸一化的目的

使得某一特徵不會對最終結果造成比其他特徵更大的影響。

1.2 特點

通過對原始資料進行變換把資料對映到(預設為[0,1])之間

注：作用於每一列，max為一列的最大值，min為一列的最小值,那麼X’’為最終結果，mx，mi分別為指定區間值預設mx為1，mi為0。

1.3 sklearn歸一化API: sklearn.preprocessing.MinMaxScaler

MinMaxScaler語法：

• MinMaxScalar(feature_range=(0,1)…)，例項化，每個特徵縮放到給定範圍(預設[0,1])
• MinMaxScalar.fit_transform(X)，X:numpy array格式的資料[n_samples,n_features]，返回值：轉換後的形狀相同的array

from sklearn.preprocessing import MinMaxScaler

def min_max():
    """歸一化處理"""
    mm = MinMaxScaler()  # 預設：MinMaxScaler(feature_range=(0, 1))
    data = mm.fit_transform([[90, 2, 10, 40], [60, 4, 15, 45], [75, 3, 13, 46]])
    print(data)
    return None


if __name__ == "__main__":
    min_max()

列印結果：

[[1.         0.         0.         0.        ]
 [0.         1.         1.         0.83333333]
 [0.5        0.5        0.6        1.        ]]

1.4 如果資料中異常點較多，會有什麼影響？

注意在特定場景下最大值最小值是變化的，另外，最大值與最小值非常容易受異常點影響，所以這種方法魯棒性較差，歸一化方法只適合傳統精確小資料場景。一般傳統精確小資料場景不多，所以在實際應用中不太用歸一化方法。

2、標準化方法(常用)

2.1 標準化的目的

使得某一特徵不會對最終結果造成比其他特徵更大的影響。

2.2 特點

通過對原始資料進行變換把資料變換到均值為0，方差為1 範圍內。

2.3 sklearn標準化API: scikit-learn.preprocessing.StandardScaler

StandardScaler語法：

• StandardScaler(…)，例項化，處理之後每列來說所有資料都聚集在均值0附近方差為1。
• StandardScaler.fit_transform(X,y)，X:numpy array格式的資料[n_samples,n_features]，返回值：轉換後的形狀相同的array。
• StandardScaler.mean_，原始資料中每列特徵的平均值。
• StandardScaler.std_，原始資料每列特徵的方差。

from sklearn.preprocessing import StandardScaler

def stand():
    """標準化縮放"""
    std = StandardScaler()
    data = std.fit_transform([[1., -1., 3.], [2., 4., 2.], [4., 6., -1.]])
    print('data = \n', data)
    return None

if __name__ == "__main__":
    stand()

列印結果：

data = 
 [[-1.06904497 -1.35873244  0.98058068]
 [-0.26726124  0.33968311  0.39223227]
 [ 1.33630621  1.01904933 -1.37281295]]

2.4 標準化方法 V.S. 歸一化方法

歸一化：如果出現異常點，影響了最大值和最小值，那麼結果顯然會發生改變。
標準化：如果出現異常點，由於具有一定資料量，少量的異常點對於平均值的影響並不大，從而方差改變較小。在已有樣本足夠多的情況下比較穩定，適合現代嘈雜大資料場景。

3、缺失值的處理方法

注意：雖然scikit-learn也提供了缺失值的處理api，但是缺失值一般使用pandas來處理

3.1 缺失值的處理方法

• 刪除----如果每列或者行資料缺失值達到一定的比例，建議放棄整行或者整列
• 插補(常用)----可以通過缺失值每行或者每列(比按行填補靠譜)的平均值、中位數來填充

3.2 sklearn缺失值API: sklearn.preprocessing.Imputer

Imputer語法：

• Imputer(missing_values=‘NaN’, strategy=‘mean’, axis=0)，完成缺失值插補
• Imputer.fit_transform(X,y) ，X:numpy array格式的資料[n_samples,n_features]，返回值：轉換後的形狀相同的array

Imputer流程：

1. 初始化Imputer,指定”缺失值”，指定填補策略，指定行或列(缺失值也可以是別的指定要替換的值)；
2. 呼叫fit_transform方法輸入資料並轉換；

from sklearn.preprocessing import Imputer
import numpy as np

def im():
    """缺失值處理"""
    # NaN, nan 兩種寫法都可以
    im = Imputer(missing_values='NaN', strategy='mean', axis=0)	# axis=0 表示按列求平均值
    data = im.fit_transform([[1, 2], [np.nan, 3], [7, 6]])
    print('data = \n', data)
    return None

if __name__ == "__main__":
    im()

列印結果：

data = 
 [[1. 2.]
 [4. 3.]
 [7. 6.]]

3.3 關於np.nan(np.NaN)

• numpy的陣列中可以使用np.nan/np.NaN來代替缺失值，屬於float型別
• 如果是檔案中的一些缺失值，可以替換成nan，通過np.array轉化成float型的陣列即可

三、資料降維(維度：特徵的數量)

資料降維不是指資料矩陣的維度，而是指特徵數量的減少。
資料降維方法：特徵選擇、主成分分析。

1、特徵選擇

特徵選擇就是單純地從提取到的所有特徵中選擇部分特徵作為訓練集特徵，特徵在選擇前和選擇後可以改變值、也不改變值，但是選擇後的特徵維數肯定比選擇前小，畢竟我們只選擇了其中的一部分特徵。
特徵選擇原因----冗餘：部分特徵的相關度高，容易消耗計算效能；噪聲：部分特徵對預測結果有負影響

特徵選擇主要方法（三大武器）：

• Filter(過濾式)：VarianceThreshold
• Embedded(嵌入式)：正則化、決策樹
• 神經網路
• Wrapper(包裹式)：基本用不到

1.1 Filter(過濾式)：VarianceThreshold

原則：把特徵值差不多的特徵刪除掉，該特徵對預測的作用不大。
用到的類：sklearn.feature_selection.VarianceThreshold，利用方差(Variance)進行過濾。
VarianceThreshold語法：

1. VarianceThreshold(threshold = 0.0)，刪除所有低方差特徵
2. Variance.fit_transform(X,y)，X:numpy array格式的資料[n_samples,n_features]，返回值：訓練集差異低於threshold的特徵將被刪除。預設值是保留所有非零方差特徵，即刪除所有樣本中具有相同值的特徵。

VarianceThreshold流程

1. 初始化VarianceThreshold,指定閥值方差。閥值方差根據實際情況來選擇。閥值方差可以選0~9範圍內的所有數，沒有一個最好值，得根據實際效果來選擇。
2. 呼叫fit_transform

from sklearn.feature_selection import VarianceThreshold

def var():
    """特徵選擇-刪除低方差的特徵"""
    var = VarianceThreshold()   # 預設：threshold=0.0
    data = var.fit_transform([[0, 2, 0, 3], [0, 1, 4, 3], [0, 1, 1, 3]])
    print('data = \n', data)
    return None

if __name__ == "__main__":
    var()

列印結果：

data = 
 [[2 0]
 [1 4]
 [1 1]]

1.2 Embedded(嵌入式)：正則化、決策樹

1.3 神經網路

2、主成分分析(PCA)

本質：PCA是一種分析、簡化資料集的技術(當特徵數量達到上百的時候，考慮資料的簡化)。
目的：是資料維數壓縮，儘可能降低原資料的維數（複雜度），損失少量資訊。在降低維度時，儘可能減少損失。
作用：可以削減迴歸分析或者聚類分析中特徵的數量。
用到的類：sklearn.decomposition

高維度資料容易出現的問題：特徵之間通常是線性相關的或近似線性相關。
通過旋轉矩陣將原矩陣旋轉到各個點的x座標或y座標儘可能不相等。

二維旋轉矩陣：P = $\left[\begin{array}{cc}sin\theta & -sin\theta \\ cos\theta & cos\theta \end{array}\right]$ $\stackrel{\text{θ=45°}}{===}$ $\left[\begin{array}{cc}\frac{1}{\sqrt{2}}& -\frac{1}{\sqrt{2}}\\ \frac{1}{\sqrt{2}}& \frac{1}{\sqrt{2}}\end{array}\right]$

Y’ = P * X = $\left[\begin{array}{cc}\frac{1}{\sqrt{2}}& -\frac{1}{\sqrt{2}}\\ \frac{1}{\sqrt{2}}& \frac{1}{\sqrt{2}}\end{array}\right]$ * $\left[\begin{array}{ccccc}-1& -1& 0& 2& 0\\ -2& 0& 0& 1& 1\end{array}\right]$ = $\left[\begin{array}{ccccc}\frac{1}{\sqrt{2}}& -\frac{1}{\sqrt{2}}& 0& \frac{1}{\sqrt{2}}& -\frac{1}{\sqrt{2}}\\ -\frac{3}{\sqrt{2}}& -\frac{1}{\sqrt{2}}& 0& \frac{3}{\sqrt{2}}& \frac{1}{\sqrt{2}}\end{array}\right]$

Y’矩陣的第2行資料(y資料)各不相同，可以用來做降維處理。選取旋轉矩陣P的第二行作為一維向量，左乘矩陣X得到一個一維矩陣。

Y’ = P * X = $\left[\begin{array}{cc}\frac{1}{\sqrt{2}}& \frac{1}{\sqrt{2}}\end{array}\right]$ * $\left[\begin{array}{ccccc}-1& -1& 0& 2& 0\\ -2& 0& 0& 1& 1\end{array}\right]$ = $\left[\begin{array}{ccccc}-\frac{3}{\sqrt{2}}& -\frac{1}{\sqrt{2}}& 0& \frac{3}{\sqrt{2}}& \frac{1}{\sqrt{2}}\end{array}\right]$