特征降维 实例

0_5.txt

00000000000000110000000000000000

00000000000011111100000000000000

00000000000111111110000000000000

00000000001111111111000000000000

00000000111111111111100000000000

00000001111111111111110000000000

00000000111111111111111000000000

00000000111111100001111100000000

00000001111111000001111100000000

00000011111100000000111100000000

00000011111100000000111110000000

00000011111100000000011110000000

00000011111100000000011110000000

00000001111110000000001111000000

00000011111110000000001111000000

00000011111100000000001111000000

00000001111100000000001111000000

00000011111100000000001111000000

00000001111100000000001111000000

00000001111100000000011111000000

00000000111110000000001111100000

00000000111110000000001111100000

00000000111110000000001111100000

00000000111110000000011111000000

00000000111110000000111111000000

00000000111111000001111110000000

00000000011111111111111110000000

00000000001111111111111110000000

00000000001111111111111110000000

00000000000111111111111000000000

00000000000011111111110000000000

00000000000000111111000000000000

#-*- coding: utf-8 -*-
‘‘‘
Created on Mar 8, 2011

@author: Peter
‘‘‘
from numpy import *
from numpy import linalg as la

#输入数据：用户-菜肴
#行：用户，列：菜肴
#数字表示用户对菜肴的喜好评分1-5,0表示未品尝该菜
def loadExData0():
    return[[0, 0, 0, 2, 2],
           [0, 0, 0, 3, 3],
           [0, 0, 0, 1, 1],
           [1, 1, 1, 0, 0],
           [2, 2, 2, 0, 0],
           [5, 5, 5, 0, 0],
           [1, 1, 1, 0, 0]]

def loadExData():
    return[[4, 4, 0, 2, 2],
            [4, 0, 0, 3, 3],
            [4, 0, 0, 1, 1],
            [1, 1, 1, 2, 0],
            [2, 2, 2, 0, 0],
            [1, 1, 1, 0, 0],
            [5, 5, 5, 0, 0]]

def loadExData2():
    return[[0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 5],
           [0, 0, 0, 3, 0, 4, 0, 0, 0, 0, 3],
           [0, 0, 0, 0, 4, 0, 0, 1, 0, 4, 0],
           [3, 3, 4, 0, 0, 0, 0, 2, 2, 0, 0],
           [5, 4, 5, 0, 0, 0, 0, 5, 5, 0, 0],
           [0, 0, 0, 0, 5, 0, 1, 0, 0, 5, 0],
           [4, 3, 4, 0, 0, 0, 0, 5, 5, 0, 1],
           [0, 0, 0, 4, 0, 4, 0, 0, 0, 0, 4],
           [0, 0, 0, 2, 0, 2, 5, 0, 0, 1, 2],
           [0, 0, 0, 0, 5, 0, 0, 0, 0, 4, 0],
           [1, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0]]

def loadExData1():
    return[[2, 0, 0, 4, 4, 0, 0, 0, 0, 0, 0],
           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5],
           [0, 0, 0, 0, 0, 0, 0, 1, 0, 4, 0],
           [3, 3, 4, 0, 3, 0, 0, 2, 2, 0, 0],
           [5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0],
           [0, 0, 0, 0, 0, 0, 5, 0, 0, 5, 0],
           [4, 0, 4, 0, 0, 0, 0, 0, 0, 0, 5],
           [0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4],
           [0, 0, 0, 0, 0, 0, 5, 0, 0, 5, 0],
           [0, 0, 0, 3, 0, 0, 0, 0, 4, 5, 0],
           [1, 1, 2, 1, 1, 2, 1, 0, 4, 5, 0]]

#基于欧氏距离的相似度：1/(1+欧氏距离)
def ecludSim(inA,inB): #A,B两个样本向量
    #库函数la.norm（）计算欧式距离
    return 1.0/(1.0 + la.norm(inA - inB))

#基于皮尔森相关系数的相似度：0.5+0.5*corrcoef()
def pearsSim(inA,inB):
    if len(inA) < 3 : return 1.0
    #corrcoef()返回的是2*2的对称矩阵,索引[0][1]或者[1][0]都行
    #并将值范围[-1,1]归一化到[0,1]
    return 0.5+0.5*corrcoef(inA, inB, rowvar = 0)[0][1]

#基于余弦夹角的相似度
def cosSim(inA,inB):
    num = float(inA.T*inB)
    denom = la.norm(inA)*la.norm(inB)
    #将余弦夹角值[-1,1]归一化到[0,1]
    return 0.5+0.5*(num/denom)

#基于物品相似度，计算用户对物品的评分估计值
#输入：dataMat 用户数据
#user：用户编号（行）
#simMeas：相似度计算函数
#item:物品编号（列），用户待预测的物品
def standEst(dataMat, user, simMeas, item):
    #数据矩阵列，即为物品数
    n = shape(dataMat)[1]
    simTotal = 0.0; ratSimTotal = 0.0

    #遍历所有物品
    for j in range(n):
        #用户user对j物品评分
        userRating = dataMat[user,j]
        #（1）若未对物品j评分，即userRating=0，不处理
        if userRating == 0: continue
        #（2）若对物品j评分：
        #统计对物品item和物品j都评分的用户编号
        overLap = nonzero(logical_and(dataMat[:,item].A>0,                                       dataMat[:,j].A>0))[0]
        #（2.1）若没有用户同时对物品item和j评分，则两物品间相似度为0
        if len(overLap) == 0: similarity = 0
        #（2.2）若有用户同时对物品item和j评分，抽取出来，计算相似度
        else: similarity = simMeas(dataMat[overLap,item],dataMat[overLap,j])
        print ‘the %d and %d similarity is: %f‘ % (item, j, similarity)
        #相似度求和
        simTotal += similarity
        #预测用户user对物品item评分总和
        ratSimTotal += similarity * userRating
    if simTotal == 0: return 0
    #归一化预测评分
    else: return ratSimTotal/simTotal

#基于SVD的评分估计
#输入：dataMat 用户数据
#user：用户编号（行）
#simMeas：相似度计算函数
#item:物品编号（列），用户待预测的物品
def svdEst(dataMat, user, simMeas, item):
    #物品数
    n = shape(dataMat)[1]
    simTotal = 0.0; ratSimTotal = 0.0
    #SVD分解
    U,Sigma,VT = la.svd(dataMat)
    #构建对角矩阵，取前3个奇异值
    #3个额外算出来的，确保总能量>90%
    Sig3 = mat(eye(3)*Sigma[:3])
    #SVD降维，重构低维空间的物品#.I求逆
    xformedItems = dataMat.T * U[:,:3] * Sig3.I
    #遍历所有物品
    for j in range(n):
        #用户user对j物品评分
        userRating = dataMat[user,j]
        #若未对物品j评分，即userRating=0，不处理
        if userRating == 0 or j==item: continue
        #在低维空间计算物品j与物品item的相似度
        similarity = simMeas(xformedItems[item,:].T,                             xformedItems[j,:].T)
        print ‘the %d and %d similarity is: %f‘ % (item, j, similarity)
        #相似度求和
        simTotal += similarity
        #预测用户user对物品item评分总和
        ratSimTotal += similarity * userRating
    if simTotal == 0: return 0
    #归一化预测评分
    else: return ratSimTotal/simTotal

#基于物品相似度的推荐
#dataMat：  数据
#user：     用户编号
# N：       选择预测评分最高的N个结果
#simMeas：  相似度计算方法
#estMethod：用户对物品的预测估分方法
def recommend(dataMat, user, N=3, simMeas=cosSim, estMethod=standEst):
    #找没有被用户user评分的物品
    unratedItems = nonzero(dataMat[user,:].A==0)[1]
    #若都评分则退出，不需要再推荐
    if len(unratedItems) == 0: return ‘you rated everything‘
    itemScores = []
    #遍历未评分的物品
    for item in unratedItems:
        #预测用户user对为评分物品item的估分
        estimatedScore = estMethod(dataMat, user, simMeas, item)
        #存（物品编号，对应估分值）
        itemScores.append((item, estimatedScore))
    #选择最高的估分结果
    return sorted(itemScores, key=lambda jj: jj[1], reverse=True)[:N]

#*****图像输出
def printMat(inMat, thresh=0.8):
    for i in range(32):
        for k in range(32):
            #阈值>0.8，输出1.
            if float(inMat[i,k]) > thresh:
                print 1,
            #阈值<0.8，输出0.
            else: print 0,
        print ‘‘

#*****图像压缩
def imgCompress(numSV=3, thresh=0.8):
    myl = []
    #读.txt文件，转换为矩阵存储到myMat中
    for line in open(‘0_5.txt‘).readlines():
        newRow = []
        for i in range(32):
            newRow.append(int(line[i]))
        myl.append(newRow)
    myMat = mat(myl)

    print "****original matrix******"
    #输出阈值处理的图像
    printMat(myMat, thresh)
    #SVD分解
    U,Sigma,VT = la.svd(myMat)
    #初始化numSV*numSV的零矩阵SigRecon
    SigRecon = mat(zeros((numSV, numSV)))
    #Sigma对角线前numSV个值重构对角矩阵SigRecon
    for k in range(numSV):
        SigRecon[k,k] = Sigma[k]
    #重构后的图像矩阵
    reconMat = U[:,:numSV]*SigRecon*VT[:numSV,:]
    print "****reconstructed matrix using %d singular values******" % numSV
    #输出阈值处理后的重构图像
    printMat(reconMat, thresh)

if __name__=="__main__":
    imgCompress(2)
    # #（1）*****测试奇异值分解的结果：
    # data=[[1,1,1,0,0],
    #       [2,2,2,0,0],
    #       [1,1,1,0,0],
    #       [5,5,5,0,0],
    #       [1,1,0,2,2],
    #       [0,0,0,3,3],
    #       [0,0,0,1,1]]
    # U,sigma,VT=linalg.svd(data)
    # print‘sigma=‘,sigma
    # print‘U=‘,U
    # print‘VT=‘,VT
    # # #低秩重构,取前3个奇异值
    # sigma3=mat([[sigma[0],0,0],[0,sigma[1],0],[0,0,sigma[2]]])
    # recondata=U[:,:3]*sigma3*VT[:3,:]
    # print‘recondata=‘
    # print recondata

##    #(2)*****基于物品相似度的推荐，未用到SVD
##    data=loadExData()
##    #data=loadExData2() #用的是loadExData2()
##    data=mat(data)
##    itemscores=recommend(data,5) #对用户2推荐
##    print ‘recommend result:‘
##    print itemscores

   #  #(3)*****svd 查看能量分布
   #  data=loadExData2()
   #  u,sigma,vT=linalg.svd(mat(data))
   #  print ‘sigma=‘, sigma
   #  sigma2=sigma**2
   #  print ‘all energy=‘,sum(sigma2)#总能量
   #  print ‘90% of all energy=‘,sum(sigma2)*0.9 #总能量的90%
   #  #sigma_len=len(sigma) #奇异值个数
   # # for i in range(sigma_len)
   #  print ‘energy of the first 2 Singular value=‘,sum(sigma2[:2])#前几个奇异值能量求和
   #  print ‘energy of the first 3 Singular value=‘,sum(sigma2[:3])
   #
   #
   #  ##(4)*****基于svd推荐：
   #  data=loadExData2()
   #  data=mat(data)
   #  itemscores=recommend(data,1,estMethod=svdEst) #对用户1推荐,余弦夹角
   #  #对用户1推荐，皮尔逊系数
   #  #itemscores=svdRec.recommend(data,1,estMethod=svdRec.svdEst,simMeas=svdRec.pearsSim)
   #  print ‘recommend result:‘
   #  print itemscores

#-*- coding: utf-8 -*-
from numpy import*
from numpy import linalg as la

import svdRec

#图像SVD压缩
svdRec.imgCompress(2)

###*****SVD的调用，及sigma输出格式，如何取对角矩阵
##data=[[1, 1, 1, 0, 0],
##      [2, 2, 2, 0, 0],
##      [1, 1, 1, 0, 0],
##      [5, 5, 5, 0, 0],
##      [1, 1, 0, 2, 2],
##      [0, 0, 0, 3, 3],
##      [0, 0, 0, 1, 1]]
##
##u,sigma,vT=linalg.svd(data)
##print sigma
##sig3=mat([[sigma[0],0,0],[0,sigma[1],0],[0,0,sigma[2]]])
##recondata=u[:,:3]*sig3*vT[:3,:]
##print ‘recondata=‘,recondata

##
###*****基于物品相似度的推荐，未用到SVD
##data=svdRec.loadExData() #用的是loadExData()
###data=svdRec.loadExData2() #用的是loadExData2()
##data=mat(data)
##itemscores=svdRec.recommend(data,2) #对用户2推荐
##print ‘recommend result:‘
##print itemscores

###*****svd 查看能量分布
##data=svdRec.loadExData2()
##u,sigma,vT=linalg.svd(mat(data))
##print ‘sigma=‘, sigma
##sigma2=sigma**2
##print ‘all energy=‘,sum(sigma2)#总能量
##print ‘90% of all energy=‘,sum(sigma2)*0.9 #总能量的90%
##print ‘energy of the first 2 Singular value=‘,sum(sigma2[:2])#前几个奇异值能量求和
##print ‘energy of the first 3 Singular value=‘,sum(sigma2[:3])
##

####*****基于svd推荐：
##data=svdRec.loadExData2()
##data=mat(data)
##itemscores=svdRec.recommend(data,1,estMethod=svdRec.svdEst) #对用户1推荐,余弦夹角
###对用户1推荐，皮尔逊系数
###itemscores=svdRec.recommend(data,1,estMethod=svdRec.svdEst,simMeas=svdRec.pearsSim)
##print ‘recommend result:‘
##print itemscores
时间： 2024-10-24 11:03:05

特征降维 实例的相关文章

奇异值分解（SVD）的之低秩近似和特征降维

我们在这一篇<模式识别.推荐系统中常用的两种矩阵分解-----奇异值分解和非负矩阵分解 >中详细介绍了矩阵奇异值分解的数学证明,我们沿用这一篇的博文的符号,继续讨论这一章的内容. 矩阵的奇异值分解定理: 设矩阵,秩为,,则该矩阵可以分解为: 也可以表示为: . 其中:为矩阵(或者)的非零向量,为的对应特征向量,为的对应特征向量,. SVD的第一个作用之低秩近似(Low Rank Approximation): ,, 即用矩阵近似. SVD的第二个作用之特征降维(Dimensionality R

ng机器学习视频笔记（十二） ——PCA实现样本特征降维

ng机器学习视频笔记(十二) --PCA实现样本特征降维 (转载请附上本文链接--linhxx) 一.概述 所谓降维(dimensionality reduction),即降低样本的特征的数量,例如样本有10个特征值,要降维成5个特征值,即通过一些方法,把样本的10个特征值映射换算成5个特征值. 因此,降维是对输入的样本数据进行处理的,并没有对预测.分类的结果进行处理. 降维的最常用的方法叫做主成分分析(PCA,principal component analysis).最常用的业务场景是数据压

降维实例之主成分分析

数据集来源:https://www.kaggle.com/psparks/instacart-market-basket-analysis 思路: 实例代码: import pandas as pd from sklearn.decomposition import PCA def main(): ''' 降维实例:主成分分析 :return: None ''' # 读取数据 prior = pd.read_csv("order_products__prior.csv") produc

特征选择与特征降维

# coding = utf-8 from sklearn.feature_selection import VarianceThreshold from sklearn.decomposition import PCA ''' 数据降维:特征的数量减少(即columns减少) 1.特征选择原因: 1.数据冗余:部分特征的相关度高,容易消耗计算机性能 2.噪声:部分特征对预测结果有影响 2.特征选择 方式1: Filter(过滤式 VarianceThreshold): 从方差大小考虑样本的数据

特征布局实例讲习

特征布局实例讲习 1.特征布局:翻页(所需知识点:盒模型.内联元素) 2.特征布局:导航条01(所需知识点:盒模型.行内元素布局) 3.特征布局:导航条02(所需知识点:盒模型.浮动.定位.字体对齐) 4.特征布局:图片列表(所需知识点:盒模型.浮动) 5.特征布局:新闻列表(所需知识点:盒模型.浮动) 课后练习 原文地址:https://www.cnblogs.com/King-boy/p/12246969.html

特征降维

一.特征规约/降维:去掉可分性不强和冗余的特征 特征选择:去掉可分性不强的特征 特征抽取/变换:去掉多余的特征,即抽取出来的特征不存在线性or非线性关系 ============================================================================= 二.特征选择:根据在特征选择过程有无使用学习算法,特征选择可以分为: Filter:criterion为根据subset evolution or term evolution 的好坏 So

机器学习之路：python 特征降维 主成分分析 PCA

python3 学习api使用 主成分分析方法实现降低维度 使用了网络上的数据集,我已经下载到了本地,可以去我的git上参考 git:https://github.com/linyi0604/MachineLearning 代码: 1 from sklearn.svm import LinearSVC 2 from sklearn.metrics import classification_report 3 from sklearn.decomposition import PCA 4 impo

高维特征降维方法-随机映射

%生成随机矩阵并标准正交化 a= randn(3)orth(a) %随机投影进行降维 c=magic(3)d=c*b %验证距离 sim=squareform(pdist(d,'euclidean'))sim=squareform(pdist(c,'euclidean'))sim=squareform(pdist(b,'euclidean')) 参考文章: http://xueshu.baidu.com/s?wd=paperuri%3A%28f13f07876aa5d65d72fe4722c62

特征降维 理论

特征值分解 奇异值分解SVD Python实现SVD 低阶近似 奇异值选取策略 相似度计算 基于物品相似度 基于物品相似度的推荐步骤 利用物品相似度预测评分 基于物品相似度的推荐结果 利用SVD降维 利用SVD降维前后结果比较 基于SVD的图像压缩–阈值处理 基于SVD的图像压缩