精华内容
下载资源
问答
  • 数据挖掘实例

    千次阅读 2018-12-28 16:48:15
    Series是一个类似数组的对象,包含一个数组的数据(任何的Numpy的数据累心)和一个与数组关联的数据标签,被叫做索引。最简单的Series是由一个数组的数据构成。 In: obj = Series([4, 7, -5, 3]) In :obj ...

    1.Numpy基础

    1.创建数组

    创建一维数组

    import numpy as np
    a = np.arange(5)
    
    注:将0 ,1, 2, 3, 4赋值给a这个变量

    创建m*n的多维数组

    import numpy  as np
    
    def cnmda(m,n):
        '''创建numpy数组
        参数:
        m:第一维的长度
        n:第二维的长度
        '''
        ret = 0
        
        n = [y for y in range(n)]
        ret = np.array([n]*m)
    
        return ret
    

    2.数组的基本运算

    二维数组

    a = np.array( [ [1, 2 , 3],[4 ,5 , 6] ] )

    b = np.array( [ [ 4, 5, 6], [1, 2, 3] ] )

    二维数组矩阵转置

    In: a.T
    Out: array([[1,4],
                [2,5]
                [3, 6])

    二维数组的加和乘

    import numpy  as np
    
    #定义函数
    def opeadd(m, b, n):
        '''
        m:是一个数组
        b: 是一个列表
        n: 是列表的索引
        返回 m+b[n] 
    '''
        ret = 0
    #创建多维数组, 并赋值给ret
        ret  = m + b[n]
        return ret
    
    def opemul(m,b ,n):
        '''
         m:是一个数组
        b: 是一个列表
        n: 是列表的索引
        返回 m*b[n] 
        '''
        ret = 0
    #创建多维数组,并赋值给ret
        ret = m* b[n]
        return ret

    3.numpy数组的切片和索引

    import numpy as  np
     def ce(a, m, n):
        '''
        a:是一个numpy数组
        m:是第m维数组的索引
        n:第m维数组的前n个元素的索引
        你需要做的是 m+b[n]
        返回值:
        ret:一个Numpy数组
    '''
        ret = 0
        #实现找出多维数组a中第m个数组的前n个元素 并赋值给ret
        
        ret = a[m, :n]
        return ret

    4.numpy数组的堆叠

    改变数组的形状

     b = np.arange(24).reshape(2, 3, 4)

    reshape()

    import numpy as np
    In: b = np.arange(24).reshape(2, 3, 4)
    Out: b
    Out:  array([ [ [0, 1, 2, 3],
                    [4, 5, 6, 7],
                    [8, 9, 10, 11]],
                    
                   [
                    [12, 13,14, 15],
                    [15, 16, 17, 18],
                    [19, 20, 21, 22,23] ]
                    ]  )

    ravel():拆解,将多维数组变成一维数组

    In: b.ravel()
    Out: array(
               [0, 1, 2, 3,
               4, 5, 6, 7,
               8, 9, 10, 11,
               12, 13,14, 15,
               16, 17, 18,
               19, 20, 21, 22,23 ])

    flatten():拉直,其功能与ravel()相同,但是flatten()返回的是真实的数组,需要分配新的内存空间,而ravel()仅仅是改变视图。

     

    shape():使用元组改变数组形状

    In: b.shape = (6,4)
    In: b
    out: array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11],
           [12, 13, 14, 15],
           [16, 17, 18, 19],
           [20, 21, 22, 23]])

    transpose():转置

    In: b.transpose()
    Out: array([[ 0,  4,  8, 12, 16, 20],
           [ 1,  5,  9, 13, 17, 21],
           [ 2,  6, 10, 14, 18, 22],
           [ 3,  7, 11, 15, 19, 23]])

    数组的堆叠

    创建两个数组

    In: a = np.arange(9).reshape(3,3)
    In: a
    Out: array([[0, 1, 2],
           [3, 4, 5],
           [6, 7, 8]])
    In: b = a*2
    In: b
    Out: array([[ 0,  2,  4],
           [ 6,  8, 10],
           [12, 14, 16]])

    hstack():水平叠加

    In: np.hstack((a, b))# 注意这是两个括号
    Out: array([[ 0,  1,  2,  0,  2,  4],
           [ 3,  4,  5,  6,  8, 10],
           [ 6,  7,  8, 12, 14, 16]])

    vstack():垂直叠加

    In: np.vstack((a, b))
    Out:array([[ 0,  1,  2],
           [ 3,  4,  5],
           [ 6,  7,  8],
           [ 0,  2,  4],
           [ 6,  8, 10],
           [12, 14, 16]])

    dstack():深度叠加

    In : np.dstack((a, b))
    Out: array([[[ 0,  0],
            [ 1,  2],
            [ 2,  4]],
    
           [[ 3,  6],
            [ 4,  8],
            [ 5, 10]],
    
           [[ 6, 12],
            [ 7, 14],
            [ 8, 16]]])

    实例:

    import numpy as np
    def varray(m,n):
        '''
        m:是第一个数组
        n:是第二个数组
        ret:一个numpy数组
    '''
        ret = 0
       # 实现数组的垂直叠加并赋值给ret
        ret = np.vstack((m, n))
        return ret
    
    def darray(m, n):
        ret = 0
        #实现数组的深度叠加并赋值给ret
        ret = np.dstack((m,n))
        return ret
    def harray(m, n):
        ret = 0 
        #实现数组的水平叠加并赋值给ret
        ret = np.hstack((m, n))
        return ret

    5.Numpy的拆分

    拆分数组

    新建数组

    import numpy as np
    In: a= np.arange(9).reshape(3,3)
    In: a
    Out: array([[0, 1, 2],
           [3, 4, 5],
           [6, 7, 8]])

    hsplit():横向拆分

    In: np.hsplit(a,3)
    Out: [ array([[0],[3], [6]]),
           array([[1], [4],[7]]), 
           array([[2],[5], [8]])   ]

    vsplit():纵向拆分

    In: np.vsplit(a,3)
    Out: [ array([[0, 1, 2]]),
           array([[3, 4, 5]]),
           array([[6, 7, 8]])  ]

    dsplit():深度拆分

    深度拆分要求数组的的秩大于等于3

    c= np.arange(27).reshape(3,3,3)
    In: np.dsplit(c,3)
    Out:[
        array([
               [[ 0], [ 3], [ 6]],
               [[ 9], [12],[15]],
               [[18], [21], [24]]
                ]), 
    
        array([
            [[ 1], [ 4],[ 7]],
            [[10],[13],[16]],
            [[19], [22],[25]]
            ]), 
        
        array([
            [[ 2], [ 5],[ 8]],
            [[11],[14],[17]],
            [[20], [23],[26]]
            ])
        ]

    实例

    import numpy as np
    
    def vsarray(m, n):
        '''
        m: 第一个数组
        n: 是需要拆分到的维度
        返回值
        ret: 一个Numpy数组
      '''
        ret = 0
        #实现数组的纵向拆分并赋值给ret
        ret = np.vsplit(m,n)
        return ret
    def hsarray(m,n):
        ret = 0
        #实现数组的水平拆分并赋值给ret
        ret = np.hsplit(m,n)
        return ret
    def dsarray(m, n):
         ret =0
        #实现数组的深度拆分并赋值给ret
        ret = np.dsplit(m, n)
        return ret

    2.pandas基础

    1.了解数据的处理对象--series

    数据结构:

    Series:一维数组,类似于Python中的基本数据结构list,区别是Series只允许存储相同的数据类型,这样可以更有效的使用内存,提高运行效率。

    DataFrame:二维的表格型数据结构,可以理解为Series容器。

    Panel:三维的数组,可以理解为DataFrame容器。

     

    Series是一个类似数组的对象,包含一个数组的数据(任何的Numpy的数据累心)和一个与数组关联的数据标签,被叫做索引。最简单的Series是由一个数组的数据构成。

    In: obj = Series([4, 7, -5, 3])
    
    In  :obj
    
    Out :
    
    0 4
    
    1 7
    
    2  -5
    
    3  3

    创建一个带有索引来确定每个数据点的Series 

    In :obj2=Series([4,7,-5,3],index=['d','b','a','c'])
    In :obj2
    Out:
    d 4
    b 7
    a -5
    c 3

    通过传递字典来创建一个Series

    In :sdata={'Ohio':35000,'Texas':71000,'Oregon':16000,'Utah':5000}
    In :obj3=Series(sdata)
    In :obj3
    Out:
    Ohio   35000
    Texas  71000
    Oregon 16000
    Utah   5000

    实例

    1. 创建一个名为series_a的series数组,当中值为[1,2,5,7],对应的索引为['nu', 'li', 'xue', 'xi']
    2. 创建一个名为dict_a的字典,字典中包含如下内容{'ting':1, 'shuo':2, 'du':32, 'xie':44}
    3. 将dict_a字典转化成名为series_b的series数组。
    # -*- coding: utf-8 -*-
    from pandas import Series,DataFrame\
    import pandas as pd
    
    def create_series():
        '''
        返回值:
        series_a:一个Series类型的数据
        series_b: 一个Series类型的数据
        dict_a: 一个字典类型的数据
    
        series_a = Series([1,2,5,7], index= ['nu', 'li', 'xue','xi'])
        dict_a = {'ting':1, 'shuo':2, 'du':32, 'xie':44}
        series_b = Series(dict_a)
    
        return series_a, dict_a, series_b

     

     

    DataFrame是一个表格型数据结构,是以一个或多个二维块存放的数据表格(层次化索引),DataFrame即有行索引还有列索引,他有一组有序的列,每个列既可以是不同的类型(数值、字符串、布尔型)的数据,也可以看做由Series组成的字典。

    DataFrame创建:

    dictionary = {   'state'['0hio','0hio','0hio','Nevada','Nevada'],
    'year':[2000,2001,2002,2001,2002],
    'pop':[1.5,1.7,3.6,2.4,2.9] }
    
    
    frame = DataFrame(dictionary)

    修改行名:

    frame = DataFrame(dictionary, index =['one','two','three','four','five'])

     

    添加修改:

    frame[add] = [[0,0,0,0,0]

    添加Series类型:

    value =Series([1,3,1,4,6,8],index = [0,1,2,3,4,5])
    frame['add1'] = value

    实例:、

    1. 创建一个五行三列的名为 df1 的DataFrame数组,列名为 [states,years,pops],行名['one','two','three','four','five']
    2. 给df1添加新列,列名为 new_add,值为[7,4,5,8,2]
    from pandas import Series,DataFrame
    import pandas as pd
    
    def create_dataFrame():
        '''
        返回值:
        df1: 一个DataFrame数据
    '''
    #**********************************#
        dictionary = {
            'states':['0hio','0hio','0hio','Nevada','Nevada'],
            'years':[2000,2001,2002,2001,2002],
            'pops':[1.5,1.7,3.6,2.4,2.9]  }
        df1 = DataFrame(dictionary)
        df1 = DataFrame(dictionary, index=['one','two','three','four','five'])
        df1['new_add'] =[7,4,5,8,2]
        return df1

     

    2.读取csv格式数据

    读取csv,并储存在 DataFrame 中。header 关键字告诉 Pandas 哪些是数据的列名。如果没有列名的话就将它设定为 None 。

    # Reading a csv into Pandas.
    # 如果数据集中有中文的话,最好在里面加上 encoding = 'gbk' ,以避免乱码问题。后面的导出数据的时候也一样。
    
    df = pd.read_csv('uk_rain_2014.csv', header = 0)
    

    查看前n行:df.head(5)

    查看后n行:df.tail(5)

    查看总行数:len(df)

    修改列名:

    df.columns = ['water_year','rain_octsep','outflow_octsep','rain_decfeb', 'outflow_decfeb', 'rain_junaug', 'outflow_junaug']

    实例:

    1. 将test3/uk_rain_2014.csv中的数据导入到df1中;
    2. 将列名修改为['water_year','rain_octsep','outflow_octsep','rain_decfeb', 'outflow_decfeb', 'rain_junaug', 'outflow_junaug'];
    3. 计算df1的总行数并存储在length1中。
    from pandas import Series,DataFrame
    import pandas as pd
    
    def read_csv_data():
        '''
    返回值:
        df1: 一个DataFrame类型数据
        length1: 一个int类型数据
        '''
    #********************
        df1 = pd.read_csv('test3/uk_rain_2014.csv', header =0)
        df1.columns = ['water_year','rain_octsep','outflow_octsep','rain_decfeb', 'outflow_decfeb', 'rain_junaug', 'outflow_junaug']
        length1 = len(df1)
        return df1 , length1

    3.数据的基本操作-排序

    对索引进行排序

    series用sort_index()按索引排序,sort()按值排序

    1.
    In: obj = Series(range(4), index=['d','a','b','c'])
    In  obj.sort_index()  
    Out :
    a    1
    b    2
    c    3
    d    0
    
    2.
    In :frame = DataFrame(np.arange(8).reshape((2,4)),index=['three', 'one'],columns=['d','a','b','c'])
    In: frame
    
    Out:
           d  a  b  c
    three  0  1  2  3
    one    4  5  6  7
    
    In: frame.sort_index()
    Out:
           d  a  b  c
    one    4  5  6  7
    three  0  1  2  3
    
    In:frame.sort()
    Out:
           d  a  b  c
    one    4  5  6  7
    three  0  1  2  3

    按行排序

    In : frame.sort_index(axis=1, ascending = False)
    Out:
           d  c  b  a
    three  0  3  2  1
    one    4  7  6  5

    按列排序(只针对Series)

    In: obj.sort()
    In : obj
    Out:
    d    0
    a    1
    b    2
    c    3

    按值排序

    series

    In : obj =Series([4, 7, -3, 2])
    In: obj.order()
    out:
    2   -3
    3    2
    0    4
    1    7

    DataFrame:

    In: frame = DataFrame({'b':[4, 7, -3, 2], 'a':[0, 1, 0, 1]})
    In: frame.sort_values(by='b')
    Out: 
       a  b
    2  0 -3
    3  1  2
    0  0  4
    1  1  7

    实例:

    1. 对代码中s1进行按索引排序,并将结果存储到s2;
    2. 对代码中d1进行按值排序(index为f),并将结果存储到d2。
    from pandas import Series,DataFrame
    import pandas as pd
    
    def sort_gate():
        '''
        返回值:
        s2: 一个Series类型数据
        d2: 一个DataFrame类型数据
        '''
      # s1是Series类型数据,d1是DataFrame类型数据
        s1 = Series([4, 3, 7, 2, 8], index=['z', 'y', 'j', 'i', 'e'])
        d1 = DataFrame({'e': [4, 2, 6, 1], 'f': [0, 5, 4, 2]})
    
    #*******************************************************************
        s2 = s1.sort_index() 
        d2 = d1.sort_values(by='f')
        return s2,d2

    4.数据的基本操作删除

    删除指定轴上的项:即删除Series的元素或DataFrame的某一行(列)。我们可以通过对象drop(labels, axis=0)方法实现此功能。

    删除Series的一个元素:

    In: ser = Series([4.5,7.2,-5.3,3.6], index=['d','b','a','c'])
    In: ser.drop('c')
    Out: 
    d    4.5
    b    7.2
    a   -5.3

    删除DataFrame的行和列

    In: df = DataFrame(np.arange(9).reshape(3,3), index=['a','c','d'], columns=['oh','te','ca'])
    In: df
    Out: 
       oh  te  ca
    a   0   1   2
    c   3   4   5
    d   6   7   8
    
    
    In: df.drop('a')
    Out[19]: 
       oh  te  ca
    c   3   4   5
    d   6   7   8
    In: df.drop(['oh','te'],axis=1)
    Out[20]: 
       ca
    a   2
    c   5
    d   8

    注意:drop()返回的是一个新对象,元素对象不会被改变。

    实例:

    1. 在s1中删除'z'行,并赋值到s2;
    2. 在d1中删除'yy'列,并赋值到d2。
    from pandas import Series, DataFrame
    import pandas as pd
    import numpy as np
    
    def delete_data():
          '''
        返回值:
        s2: 一个Series类型数据
        d2: 一个DataFrame类型数据
        '''
        # s1是Series类型数据,d1是DataFrame类型数据
        s1 = Series([5, 2, 4, 1], index=['v', 'x', 'y', 'z'])
        d1=DataFrame(np.arange(9).reshape(3,3), columns=['xx','yy','zz'])
     
        # ********** Begin *********#
        s2 = s1.drop('z')
        d2 = d1.drop('yy')
        return s2,d2

    5.数据的基本操作-算数运算

    DataFrame中的算数运算是df中对应位置的元素的算术运算。如果没有共同的元素,则用NaN代替。

    In: df1 = DataFrame(np.arange(12.).reshape((3,4)),columns=list('abcd'))
    In: df2 = DataFrame(np.arange(20.).reshape((4,5)),columns=list('abcde'))
    In: df1+df2
    Out: 
        a   b   c   d   e
    0   0   2   4   6 NaN
    1   9  11  13  15 NaN
    2  18  20  22  24 NaN
    3 NaN NaN NaN NaN NaN

    此外,如果我们想设置默认的其他填充值吗,而非NaN的话,可以传入填充值。

    In: df1.add(df2, fill_value=0)
    Out: 
        a   b   c   d   e
    0   0   2   4   6   4
    1   9  11  13  15   9
    2  18  20  22  24  14
    3  15  16  17  18  19

    实例:

    1. 让df1与df2相加得到df3,并设置默认填充值为4。
    from pandas import Series,DataFrame
    import numpy as np
    import pandas aspd
    
    def add_way():
        '''
        返回值:
        df3: 一个DataFrame类型数据
        '''
    
        # df1,df2是DataFrame类型数据
        df1 = DataFrame(np.arange(12.).reshape((3, 4)), columns=list('abcd'))
        df2 = DataFrame(np.arange(20.).reshape((4, 5)), columns=list('abcde'))
     # ********** Begin *********#
        df3 = df1.add(df2,fill_value =4)
        return df3

    6.数据的基本操作-去重

    duplicated()

    DataFrame的duplicated方法返回一个布尔类型Series,表示各行是否是重复行。

    创建DataFrame
    In: df = DataFrame({'k1':['one']*3 + ['two']*4, 'k2':[1,1,2,3,3,4,4]})
    In: df
    Out: 
        k1  k2
    0  one   1
    1  one   1
    2  one   2
    3  two   3
    4  two   3
    5  two   4
    6  two   4
    
    
    检测:
    In: df.duplicated()
    Out: 
    0    False
    1     True
    2    False
    3    False
    4     True
    5    False
    6     True
    

    drop_duplicates()用于去除重复的行数,具体用法:

    In: df.drop_duplicates()
    Out: 
        k1  k2
    0  one   1
    2  one   2
    3  two   3
    5  two   4

    实例:

    1. 去除df1中重复的行,并把结果保存到df2中。
    from pandas import Series, DataFrame 
    import pandas as pd
    
    def delete_duplicated():
        '''
        返回值:
        df2: 一个DataFrame类型数据
        '''
    
        # df1是DataFrame类型数据
        df1 = DataFrame({'k1': ['one'] * 3 + ['two'] * 4, 'k2': [1, 1, 2, 3, 3, 4, 4]})
        
        # ********** Begin *********#
        df2 = df1.drop_duplicates()
        return df2

    7.层次化索引

    层次化索引使我们能在一个轴上拥有多个(两个以上)索引级别。

    如:

    In:data = Series(np.random.randn(10), index = [['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'd', 'd' ],[1,2,3,1,2,3,1,2,2,3]])
    In:data
    Out:
    a  1    0.169239
       2    0.689271
       3    0.879309
    b  1   -0.699176
       2    0.260446
       3   -0.321751
    c  1    0.893105
       2    0.757505
    d  2   -1.223344
       3   -0.802812

    索引方式

    In:data['b':'d']
    Out:
    b  1   -0.699176
       2    0.260446
       3   -0.321751
    c  1    0.893105
       2    0.757505
    d  2   -1.223344
       3   -0.802812

    内层选取

    In:data[:, 2]
    Out:
    a    0.689271
    b    0.260446
    c    0.757505
    d   -1.223344
    

    数据重塑

    将Series转化为DataFrame:

    In:data.unstack()
    Out:
             1          2            3
    a    0.169239    0.689271    0.879309
    b    -0.699176   0.260446  -0.321751
    c    0.893105    0.757505    NaN
    d    NaN        -1.223344   -0.802812

    实例:

    1. 对s1进行数据重塑,转化成DataFrame类型,并复制到d1。
    from pandas import Series, DataFrame
    import pandas as pd
    import numpy as np
    
    def  suosaying():
         '''
        返回值:
        d1: 一个DataFrame类型数据
        '''
        #s1是Series类型数据
        s1=Series(np.random.randn(10),
               index=[['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'd', 'd'],              [1, 2, 3, 1, 2, 3, 1, 2, 2, 3]])
     
        # ********** Begin *********#
        d1 = s1.unstack()
        return d1
    suoying()

     

    展开全文
  • python 数据挖掘篇四 小说数据挖掘实例Python 安装 python 学习 一 python 语法,及变量类型 python 学习 二 爬一个图片网站上 python 学习 二 02 爬一个图片网站,获得主链接网址,并保存 python 学习 二 03 爬一个...

    python 数据挖掘篇四 小说数据挖掘实例

    Python 安装 python 学习 一 python 语法,及变量类型 python 学习 二 爬一个图片网站上 python 学习 二 02 爬一个图片网站,获得主链接网址,并保存 python 学习 二 03 爬一个图片网站 - 获得所有分页网址 python 学习 二 04 爬一个图片网站 - 解析文件,获得所有图片链接 python 学习 二 05 爬一个图片网站 - 下载图片链接 python 学习 二 06 爬一个图片网站 - 多线程方式下载 python 学习 三 01 再爬一个网站,几行代码,搞定分类类别 python 学习 三 02 再爬一个网站,获得所有分页 python 学习 三 03 再爬一个网站,根据分页,下载图片 python 学习 三 04 图片爬虫工程 - 组织框架 Python 爬虫 上篇 Python 爬虫 下篇 python 数据挖掘篇 一 结巴分词 python 数据挖掘篇 二 词云统计 python 数据挖掘篇 三 gensim 使用 python 数据挖掘篇四 小说数据挖掘实例 第四章 小说数据挖掘实例 搜索引擎 --- 给定文字,搜索书中与之相近的文字

    示例,做一个书本的搜索引擎,输入以句话,输出与这句话最相近的段落

    ab7653affab982b574eb7acc55df2e04.gif

    ab7653affab982b574eb7acc55df2e04.gif

    分三个阶段

    1, 预处理阶段

    2, 加载预处理好的字典,语料,模型,索引阶段

    3, 查询阶段

    预处理阶段:

    ab7653affab982b574eb7acc55df2e04.gif

    ab7653affab982b574eb7acc55df2e04.gif

    加载阶段

    ab7653affab982b574eb7acc55df2e04.gif

    查询阶段

    ab7653affab982b574eb7acc55df2e04.gif

    Word2Vec 模型

    这个模型也很有意思,可以查找与某个词相近,相反,推理关系.

    ab7653affab982b574eb7acc55df2e04.gif

    ab7653affab982b574eb7acc55df2e04.gif

    总结:

    之所以研究 gensim,是想做一个古典小说搜索引擎,和小说数据分析工具.打算将网站 www.gudianxiaoshuo.com 打造成古典小说搜索,知识挖掘的网站.

    使用红楼梦做为分析对象,实现了搜索分析功能,但是也发现将预处理的信息保存到本地后,占用空间还是很大的,尤其是 lsi 语料竟然 100M,不知道还有没有更好的方法.

    ab7653affab982b574eb7acc55df2e04.gif

    项目地址:

    https://github.com/gudianxiaoshuo

    来源: http://www.jianshu.com/p/32477930b006

    展开全文
  • R数据挖掘实例.pptx

    2013-05-19 21:41:30
    \R数据挖掘实例.pptx Crime&Shock数据集分析展示
  • 企业数据挖掘实例

    2018-04-25 19:33:37
    数据挖掘...
  • sas数据挖掘实例中文稿,方便初学sas数据挖掘的人学习和实践。
  • 一个基于数据仓库web日志的数据挖掘实例,有数据挖掘的相关方法
  • 基于数据仓库的web数据挖掘实例,对于那些初学者是一个很好的学习资料。
  • SAS 8.2 Enterprise Miner数据挖掘实例
  • Python数据挖掘实例:K均值聚类任务任务要求数据预览分析代码实现结果分析数据文件链接 任务 任务要求 数据文件链接在全文的最后 借助Python软件进行上市公司财务状况数据挖掘与统计分析。 已知:132只股票、32个...

    任务

    任务要求

    数据文件链接在全文的最后
    借助Python软件进行上市公司财务状况数据挖掘与统计分析。
    已知:132只股票、32个因素变量的4个日期数据记录(共528条记录)。要求用数据挖掘软件分析如下问题:

    1. 抽取132只股票公司的财务指标数据中无缺失的指标变量数据,形成数据集X。所给数据已作一致化和无量纲化处理(压缩到[0,1])。
    2. 对每只股票,给出了4个日期下的31个指标的具体数值。可固定某一年度,对该年度下的样本进行K-均值聚类。要求考虑:
      (1)如何确定合适的聚类数目K?
      (2)以(1)获得的合适的聚类数对样本进行K-均值聚类,划分合适的股票板块。
      (3)评价各类的优劣性。

    数据预览

    在这里插入图片描述

    分析

    对于聚类数目,首先利用手肘法进行分析。

    当k小于真实聚类数时,由于k的增大会大幅增加每个簇的聚合程度,故SSE的下降幅度会很大,而当k到达真实聚类数时,再增加k所得到的聚合程度回报会迅速变小,所以SSE的下降幅度会骤减,然后随着k值的继续增大而趋于平缓,也就是说SSE和k的关系图是一个手肘的形状,而这个肘部对应的k值就是数据的真实聚类数。

    数据均为[0,1]标准化后的数据,有少部分缺失值,去缺失值后可直接掉包聚类,本文利用sklearn.cluster中的KMeans模块。由于日期有4类,首先要利用切片操作将数据集按日期分为4个子数据集。

    代码实现

    import pandas as pd
    import numpy as np
    import matplotlib.pyplot as plt
    from sklearn.cluster import KMeans
    import sklearn
    from sklearn.metrics import silhouette_score
    df = pd.read_excel(r'证券财务数据-4个日期-已类型一致化.xlsx', sep=',', encoding="utf-8")  #打开csv文件
    data = df.values
    data = data[:,1:33]
    #print(data)
    data2003 = data[::4,:]
    data2002 = data[1::4,:]
    data2001 = data[2::4,:]
    data2000 = data[3::4,:]
    df2000 = pd.DataFrame(data2000)
    df2001 = pd.DataFrame(data2001)
    df2002 = pd.DataFrame(data2002)
    df2003 = pd.DataFrame(data2003)
    print(df2000)
    #print(len(data2000))
    #sklearn.metrics.silhouette_score(data2000, metric='euclidean', sample_size=None, random_state=None)
    '''
    #手肘法
    k_range = range(2,12)
    k_scores = []
    for k in k_range:
        clf = KMeans(n_clusters=k)
        clf.fit(data2003)
        scores = clf.inertia_
        k_scores.append(scores)
    plt.plot(k_range, k_scores)
    plt.xlabel('k_clusters for Kmeans')
    plt.ylabel('inertia')
    plt.show()  # 绘制折线图并展示观察
    '''
    #下面根据手肘法结果进行聚类并写入4个excel
    clf = KMeans(n_clusters=6) 
    clf.fit(data2003)   
    result = clf.predict(df2003)
    df2003.insert(loc=32, column='tag', value=result)
    df2003.to_excel(r'result2003.xlsx', index=False, encoding="utf-8")
    
    

    结果分析

    聚类结果和优劣性分析当作作业留给读者,欢迎与博主交流聚类数目的选择和结果。

    数据文件链接

    文件:证券财务数据-4个日期-已类型一致化.xlsx
    链接:https://pan.baidu.com/s/1DxmjiY005AjACLi4-7j3yw
    提取码:ieo6

    原文链接:https://blog.csdn.net/chandler_scut/article/details/106670510

    展开全文
  • 工业数据挖掘实例

    2020-10-30 14:22:26
    数据挖掘技术根据业务数据不同有不同的应用场景。在我以往工作中主要在以下领域有应用尝试: 市场营销:用数据挖掘进行消费者画像,定向进行产品推荐 生产质量:根据质检状况,借用数据挖掘技术分析质量不合格的...

    智能的基础是智能决策,所有的决策都来自于分析。所以简单说所有的智能都是做好两件事:收集数据,使用数据。数据挖掘技术根据业务数据不同有不同的应用场景。在我以往工作中主要在以下领域有应用尝试:

    • 市场营销:用数据挖掘进行消费者画像,定向进行产品推荐
    • 生产质量:根据质检状况,借用数据挖掘技术分析质量不合格的诱因并推荐优化方案,比如机器设备参数最佳取值。
    • 能源消耗:使用数据挖掘技术分析能源消耗的超标区间,非必要能源消耗区间并推荐优化方案。
    • 设备维护:通过监控设备运行的参数性能,结合设备故障原因分析参数和故障相关性,从而进行主动性维护,减少非计划停机。
    • 智能排产:完全的自动化排产还没有实现。但是现阶段的排产算法依然可以帮助计划员减少很多考虑时间,自动提供出一定排产方案
    • 物流: 根据各区域的订单量进行前置仓和配发站点的选址

    需要指出的是,虽然目前有很多数据挖掘算法和案例,但是还是主要用于网络数据。这些算法在工业领域有明显的过拟合现象不能直接使用,需要作出一些优化调整。

    下面我用一个实际工业数据挖掘的例子来展示数据挖掘在工业领域如何应用。
    【背景介绍】这条生产线的大致工艺如下图所示:左边是生产线输入,右边是输出待检的成品,经过质检后产品又分为合格品和残次品。我们数据挖掘的目的是根据生产产品的实时质检数据动态调整机器参数以寻求产品质量的最优。
    在这里插入图片描述

    【数据采集】在这个案例中我收集三部分数据:

    1. 加工产品的基本信息,节拍时间,模具编号等信息,这些数据一般可以从MES系统中抓取。
    2. 质检机器的质检结果,包括图像和质检数据结果,以及质检部门给出的标准质检值和误差范围
    3. 对应加工时间内机器的各项参数。这些数据可以从PLC读取。PLC数据的读取可以借用OPC、物联网网关、工业数据采集卡或者外置传感器。
      【数据分析】
      在这里插入图片描述

    简单的数据挖掘步骤包括数据收集,数据清洗,模型选取和训练,模型检验和实施预测。在工业数据领域,我们必须考虑到数据纬度太大。如果直接开始模型训练,必然出现过拟合现象。而且工业数据和互联网数据有个会很大的区别。比如电流,电压和功率本身就有物理相关性。并没有必要一起作为数据分析的特征。所以在模型训练之前,我们可以先做特征选取和特征增强,减少不必要的分析风险。
    在这里插入图片描述

    数据收集和清洗之后,我们先进行一轮数据基本展示:
    在这里插入图片描述

    横坐标是时间,纵坐标是模具编号。我们很容易的发现几个问题:
    1. 质检不合格产品大多数发生在一段空档期后,也就是换模之后。这是工业界的常识,换模影响产品质量
    2. 不同模具生产的产品合格率并不一样。说明产品性能受到模具本身误差的影响。由此我们已经可以标识出一部分不合格模具。
    在这里插入图片描述

    3. 所有的分析都是需要有参照的。在本案例中,我们选取了两个区间范围。这两个范围内质检合格率较高。通过对比CP和CPK参数,我们最终选定第二区间为参照区间

    我们对机器主要参数性能也进行数据展示:
    在这里插入图片描述

    我们暂且不用计较两个参数的具体含义。但是从图上可以很容易看出来,两个参数的数据存在一些时间差。理论上各个参数应该在同一时间达到极值。虽然这样的推断并不严谨。但是我们有理由相信收集的不同机器的数据存在时间切片不对的问题。实际上,在工厂车间的很多机器都是不联网的,难免出现机器时间的不准确。
    简单的根据极值,我们进行数据平移,然后得到时间极值相吻合的数据合集。
    在这里插入图片描述

    在得到合理且高质量的数据后,我们可以进行数据分析了。
    首先,我们进行了降维操作。因为我们最终是要推荐每个机器参数的理想取值范围,所以有必要保留原始的数据维而不能使用PCA降维方法。好在我们的维度数目不算过于庞大。我么很容易用对比ROC的方式对每一个维度的影响进行了评估筛选。最终保留了以下维度。进而,我们用随机森林算法获得了每个维度的影响因子:
    在这里插入图片描述

    在此基础上,我们对质量缺陷的位置进行了汇总。
    在这里插入图片描述

    试着把机器参数和缺陷的位置进行了关系模拟。最终得出结论:对质量影响较大的是最后一道工艺的功率问题。
    在这里插入图片描述

    针对如何推荐每个参数的最佳取值范围,起初我们直接运行了随机森林算法进行模型训练和预测,发现该算法对部分产品模型过拟合程度过高,达不到要求。后来我们分别试验了SVM和决策树等不同算法。根据评选结果,最适合我们数据预测的算法是SVM。在进一步算法优化后,预测结果达到了很好的效果。
    【结果验证】
    我们在和现场工程师一起对数据挖掘算法的结果进行了理论验证。在一致通过后,我们进行了真机模拟。试验结果取得了较好的产品质量。
    【下一步工作】
    目前算法在推荐了每个机器参数的最佳取值范围后,还需要人为手动输入到机器控制板进行调整。这主要受限于PLC的安全保护,不能轻易允许数据写入。随着技术的演进,我们下一步将尝试如何让系统通过OPC把PLC的机器参数动态进行调整。

    本案例中,我们只对本部分数据进行了定向性挖掘。过程中我们也尝试横向数据挖掘,比如我们注意到合格率和操作时间也有一定关系。不过这不是本次分析的重点,在我们分析中没有深入下去。

    在这里插入图片描述

    展开全文
  • R数据挖掘实例

    2014-02-27 13:28:07
    R语言是主要用于统计分析、绘图的语言和操作环境。R本来是由来自新西兰奥克兰大学的Ross Ihaka和Robert Gentleman 开发(也因此称为R),现在由“R开发核心团队”负责开发。 R是基于S语言的一个GNU项目,所以也可以...
  • 数据挖掘实例........

    2008-12-11 01:13:29
    dffbfbgfdggdgvd不错的数据挖掘实例,没事下载下来看看!
  • 数据挖掘实例1

    2019-08-05 23:57:19
    基本数据分析: 整体数据量级:4754 1.标签列status分布: 正负样本个数: 0 3561 1 1193 2.各列特征分析 变量类型统计: 字符型特征为: trade_no bank_card_no reg_preference_for_trad source id_...
  • python 数据挖掘篇四 小说数据挖掘实例 第四章 小说数据挖掘实例 搜索引擎---给定文字,搜索书中与之相近的文字 示例,做一个书本的搜索引擎,输入以句话,输出与这句话最相近的段落 ...
  • 数据挖掘实例task3

    2019-08-12 00:08:27
    训练模型 将数据3:7划分,分别进行决策树,随机森林及xgb训练 具体如下:
  • SAS_数据挖掘实例

    2011-08-26 16:57:08
    介绍sas em 的实例使用
  • 数据挖掘实例task2

    2019-08-11 23:13:33
    分析选择特征 1.计算特征的iv值 注:对python使用较少,直接计算iv的code较少,最后找到一个包,既可以输出iv值,又可以把分箱明细输出,便于画图分析。 具体结果如下: 具体code如下: ...
  • 数据挖掘实例——信用评级

    千次阅读 2019-11-24 15:26:04
    本次的源数据是汽车违约贷款数据集accepts.csv 原始数据与源代码可以在GitHub中下载 GitHub地址 如果有兴趣可以git clone下来自己跑一跑代码 读取源数据 import os import numpy as np from scipy import stats ...
  • weka是一款由Waikato大学研究的基于Java 的用于数据挖掘和知识发现的开源项目, 其中集成了大量能承担数据挖掘任务的机器学习算法, 包括对数据进行预处理、关联规则挖掘、分类、聚类等, 并提供了丰富的可视化功能。...
  • 学习表 编写数据分析代码 编写程序对上面的数据进行决策树分类,采用信息熵(entropy)作为度量标准。参考代码如下所示: from sklearn.tree import DecisionTreeClassifier,export_graphviz import graphviz import ...
  • Python数据挖掘实例(实时更新)

    万次阅读 2017-08-15 12:29:41
    数据挖掘
  • 德国贷款公司数据挖掘案例 引用自“卡卡·我来自一塌糊涂”

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,902
精华内容 760
关键字:

数据挖掘实例