• GitHub用户分析
    • 生成图表
      • 数据解析
      • Matplotlib
    • 每周分析
      • python github 每周情况分析
      • Python 数据分析
      • Python Matplotlib图表
    • 存储到数据库中
      • SQLite3
      • 数据导入
      • Redis
        • Redis 查询
    • 邻近算法与相似用户

    GitHub用户分析

    生成图表

    如何分析用户的数据是一个有趣的问题，特别是当我们有大量的数据的时候。除了matlab，我们还可以用numpy+matplotlib

    数据可以在这边寻找到

    https://github.com/gmszone/ml

    最后效果图

    2014 01 01

    要解析的json文件位于data/2014-01-01-0.json，大小6.6M，显然我们可能需要用每次只读一行的策略，这足以解释为什么诸如sublime打开的时候很慢，而现在我们只需要里面的json数据中的创建时间。。

    ==, 这个文件代表什么？

    2014年1月1日零时到一时，用户在github上的操作，这里的用户指的是很多。。一共有4814条数据，从commit、create到issues都有。

    数据解析

    1. import json
    2. for line in open(jsonfile):
    3.     line = f.readline()

    然后再解析json

    1. import dateutil.parser
    3. lin = json.loads(line)
    4. date = dateutil.parser.parse(lin["created_at"])

    这里用到了dateutil，因为新鲜出炉的数据是string需要转换为dateutil，再到数据放到数组里头。最后有就有了parse_data

    1. def parse_data(jsonfile):
    2.     f = open(jsonfile, "r")
    3.     dataarray = []
    4.     datacount = 0
    6.     for line in open(jsonfile):
    7.         line = f.readline()
    8.         lin = json.loads(line)
    9.         date = dateutil.parser.parse(lin["created_at"])
    10.         datacount += 1
    11.         dataarray.append(date.minute)
    13.     minuteswithcount = [(x, dataarray.count(x)) for x in set(dataarray)]
    14.     f.close()
    15.     return minuteswithcount

    下面这句代码就是将上面的解析为

    1. minuteswithcount = [(x, dataarray.count(x)) for x in set(dataarray)]

    这样的数组以便于解析

    1. [(0, 92), (1, 67), (2, 86), (3, 73), (4, 76), (5, 67), (6, 61), (7, 71), (8, 62), (9, 71), (10, 70), (11, 79), (12, 62), (13, 67), (14, 76), (15, 67), (16, 74), (17, 48), (18, 78), (19, 73), (20, 89), (21, 62), (22, 74), (23, 61), (24, 71), (25, 49), (26, 59), (27, 59), (28, 58), (29, 74), (30, 69), (31, 59), (32, 89), (33, 67), (34, 66), (35, 77), (36, 64), (37, 71), (38, 75), (39, 66), (40, 62), (41, 77), (42, 82), (43, 95), (44, 77), (45, 65), (46, 59), (47, 60), (48, 54), (49, 66), (50, 74), (51, 61), (52, 71), (53, 90), (54, 64), (55, 67), (56, 67), (57, 55), (58, 68), (59, 91)]

    Matplotlib

    开始之前需要安装``matplotlib

    1. sudo pip install matplotlib

    然后引入这个库

    1.   import matplotlib.pyplot as plt

    如上面的那个结果，只需要

    2.     plt.figure(figsize=(8,4))
    3.     plt.plot(x, y,label = files)
    4.     plt.legend()
    5.     plt.show()

    最后代码可见

    1. #!/usr/bin/env python
    2. # -*- coding: utf-8 -*-
    4. import json
    5. import dateutil.parser
    6. import numpy as np
    7. import matplotlib.mlab as mlab
    8. import matplotlib.pyplot as plt
    11. def parse_data(jsonfile):
    12.     f = open(jsonfile, "r")
    13.     dataarray = []
    14.     datacount = 0
    16.     for line in open(jsonfile):
    17.         line = f.readline()
    18.         lin = json.loads(line)
    19.         date = dateutil.parser.parse(lin["created_at"])
    20.         datacount += 1
    21.         dataarray.append(date.minute)
    23.     minuteswithcount = [(x, dataarray.count(x)) for x in set(dataarray)]
    24.     f.close()
    25.     return minuteswithcount
    28. def draw_date(files):
    29.     x = []
    30.     y = []
    31.     mwcs = parse_data(files)
    32.     for mwc in mwcs:
    33.         x.append(mwc[0])
    34.         y.append(mwc[1])
    36.     plt.figure(figsize=(8,4))
    37.     plt.plot(x, y,label = files)
    38.     plt.legend()
    39.     plt.show()
    41. draw_date("data/2014-01-01-0.json")

    每周分析

    继上篇之后，我们就可以分析用户的每周提交情况，以得出用户的真正的工具效率，每个程序员的工作时间可能是不一样的，如

    Phodal Huang's Report

    这是我的每周情况，显然如果把星期六移到前面的话，随着工作时间的增长，在github上的使用在下降，作为一个

    1.   a fulltime hacker who works best in the evening (around 8 pm).

    不过这个是osrc的分析结果。

    python github 每周情况分析

    看一张分析后的结果

    Feb Results

    结果正好与我的情况相反？似乎图上是这么说的，但是数据上是这样的情况。

    1. data
    2. ├── 2014-01-01-0.json
    3. ├── 2014-02-01-0.json
    4. ├── 2014-02-02-0.json
    5. ├── 2014-02-03-0.json
    6. ├── 2014-02-04-0.json
    7. ├── 2014-02-05-0.json
    8. ├── 2014-02-06-0.json
    9. ├── 2014-02-07-0.json
    10. ├── 2014-02-08-0.json
    11. ├── 2014-02-09-0.json
    12. ├── 2014-02-10-0.json
    13. ├── 2014-02-11-0.json
    14. ├── 2014-02-12-0.json
    15. ├── 2014-02-13-0.json
    16. ├── 2014-02-14-0.json
    17. ├── 2014-02-15-0.json
    18. ├── 2014-02-16-0.json
    19. ├── 2014-02-17-0.json
    20. ├── 2014-02-18-0.json
    21. ├── 2014-02-19-0.json
    22. └── 2014-02-20-0.json

    我们获取是每天晚上0点时的情况，至于为什么是0点，我想这里的数据量可能会比较少。除去1月1号的情况，就是上面的结果，在只有一周的情况时，总会以为因为在国内那时是假期，但是总觉得不是很靠谱，国内的程序员虽然很多，会在github上活跃的可能没有那么多，直至列出每一周的数据时。

    1.   6570, 7420, 11274, 12073, 12160, 12378, 12897,
    2.   8474, 7984, 12933, 13504, 13763, 13544, 12940,
    3.   7119, 7346, 13412, 14008, 12555

    Python 数据分析

    重写了一个新的方法用于计算提交数，直至后面才意识到其实我们可以算行数就够了，但是方法上有点hack

    1. def get_minutes_counts_with_id(jsonfile):
    2.     datacount, dataarray = handle_json(jsonfile)
    3.     minuteswithcount = [(x, dataarray.count(x)) for x in set(dataarray)]
    4.     return minuteswithcount
    7. def handle_json(jsonfile):
    8.     f = open(jsonfile, "r")
    9.     dataarray = []
    10.     datacount = 0
    12.     for line in open(jsonfile):
    13.         line = f.readline()
    14.         lin = json.loads(line)
    15.         date = dateutil.parser.parse(lin["created_at"])
    16.         datacount += 1
    17.         dataarray.append(date.minute)
    19.     f.close()
    20.     return datacount, dataarray
    23. def get_minutes_count_num(jsonfile):
    24.     datacount, dataarray = handle_json(jsonfile)
    25.     return datacount
    28. def get_month_total():
    29.     """
    31.     :rtype : object
    32.     """
    33.     monthdaycount = []
    34.     for i in range(1, 20):
    35.         if i < 10:
    36.             filename = 'data/2014-02-0' + i.__str__() + '-0.json'
    37.         else:
    38.             filename = 'data/2014-02-' + i.__str__() + '-0.json'
    39.         monthdaycount.append(get_minutes_count_num(filename))
    40.     return monthdaycount

    接着我们需要去遍历每个结果，后面的后面会发现这个效率真的是太低了，为什么木有多线程？

    Python Matplotlib图表

    让我们的matplotlib来做这些图表的工作

    1. if __name__ == '__main__':
    2.     results = pd.get_month_total()
    3.     print results
    5.     plt.figure(figsize=(8, 4))
    6.     plt.plot(results.__getslice__(0, 7), label="first week")
    7.     plt.plot(results.__getslice__(7, 14), label="second week")
    8.     plt.plot(results.__getslice__(14, 21), label="third week")
    9.     plt.legend()
    10.     plt.show()

    蓝色的是第一周，绿色的是第二周，红色的是第三周就有了上面的结果。

    我们还需要优化方法，以及多线程的支持。

    让我们分析之前的程序，然后再想办法做出优化。网上看到一篇文章http://www.huyng.com/posts/python-performance-analysis/讲的就是分析这部分内容的。

    存储到数据库中

    SQLite3

    我们创建了一个名为userdata.db的数据库文件，然后创建了一个表，里面有owner,language,eventtype,name url

    1. def init_db():
    2.     conn = sqlite3.connect('userdata.db')
    3.     c = conn.cursor()
    4.     c.execute('''CREATE TABLE userinfo (owner text, language text, eventtype text, name text, url text)''')

    接着我们就可以查询数据，这里从结果讲起。

    1. def get_count(username):
    2.     count = 0
    3.     userinfo = []
    4.     condition = 'select * from userinfo where owener = \'' + str(username) + '\''
    5.     for zero in c.execute(condition):
    6.         count += 1
    7.         userinfo.append(zero)
    9.     return count, userinfo

    当我查询gmszone的时候，也就是我自己就会有如下的结果

    1. (u'gmszone', u'ForkEvent', u'RESUME', u'TeX', u'https://github.com/gmszone/RESUME')
    2. (u'gmszone', u'WatchEvent', u'iot-dashboard', u'JavaScript', u'https://github.com/gmszone/iot-dashboard')
    3. (u'gmszone', u'PushEvent', u'wechat-wordpress', u'Ruby', u'https://github.com/gmszone/wechat-wordpress')
    4. (u'gmszone', u'WatchEvent', u'iot', u'JavaScript', u'https://github.com/gmszone/iot')
    5. (u'gmszone', u'CreateEvent', u'iot-doc', u'None', u'https://github.com/gmszone/iot-doc')
    6. (u'gmszone', u'CreateEvent', u'iot-doc', u'None', u'https://github.com/gmszone/iot-doc')
    7. (u'gmszone', u'PushEvent', u'iot-doc', u'TeX', u'https://github.com/gmszone/iot-doc')
    8. (u'gmszone', u'PushEvent', u'iot-doc', u'TeX', u'https://github.com/gmszone/iot-doc')
    9. (u'gmszone', u'PushEvent', u'iot-doc', u'TeX', u'https://github.com/gmszone/iot-doc')
    10. 109
    11. `

    一共有109个事件，有Watch,Create,Push,Fork还有其他的，
    项目主要有iot,RESUME,iot-dashboard,wechat-wordpress,
    接着就是语言了，Tex,Javascript,Ruby,接着就是项目的url了。

    值得注意的是。

    1. -rw-r--r--   1 fdhuang staff 905M Apr 12 14:59 userdata.db

    这个数据库文件有905M，不过查询结果相当让人满意，至少相对于原来的结果来说。

    Python自带了对SQLite3的支持，然而我们还需要安装SQLite3

    1. brew install sqlite3

    或者是

    1. sudo port install sqlite3

    或者是Ubuntu的

    1. sudo apt-get install sqlite3

    openSUSE自然就是

    1. sudo zypper install sqlite3

    不过，用yast2也很不错，不是么。。

    数据导入

    需要注意的是这里是需要python2.7，起源于对gzip的上下文管理器的支持问题

    1. def handle_gzip_file(filename):
    2.     userinfo = []
    3.     with gzip.GzipFile(filename) as f:
    4.         events = [line.decode("utf-8", errors="ignore") for line in f]
    6.         for n, line in enumerate(events):
    7.             try:
    8.                 event = json.loads(line)
    9.             except:
    11.                 continue
    13.             actor = event["actor"]
    14.             attrs = event.get("actor_attributes", {})
    15.             if actor is None or attrs.get("type") != "User":
    16.                 continue
    18.             key = actor.lower()
    20.             repo = event.get("repository", {})
    21.             info = str(repo.get("owner")), str(repo.get("language")), str(event["type"]), str(repo.get("name")), str(
    22.                 repo.get("url"))
    23.             userinfo.append(info)
    25.     return userinfo
    27. def build_db_with_gzip():
    28.     init_db()
    29.     conn = sqlite3.connect('userdata.db')
    30.     c = conn.cursor()
    32.     year = 2014
    33.     month = 3
    35.     for day in range(1,31):
    36.         date_re = re.compile(r"([0-9]{4})-([0-9]{2})-([0-9]{2})-([0-9]+)\.json.gz")
    38.         fn_template = os.path.join("march",
    39.                                    "{year}-{month:02d}-{day:02d}-{n}.json.gz")
    40.         kwargs = {"year": year, "month": month, "day": day, "n": "*"}
    41.         filenames = glob.glob(fn_template.format(**kwargs))
    43.         for filename in filenames:
    44.             c.executemany('INSERT INTO userinfo VALUES (?,?,?,?,?)', handle_gzip_file(filename))
    46.     conn.commit()
    47.     c.close()

    executemany可以插入多条数据，对于我们的数据来说，一小时的文件大概有五六千个会符合我们上面的安装，也就是有actor又有type才是我们需要记录的数据，我们只需要统计用户的那些事件，而非全部的事件。

    我们需要去遍历文件，然后找到合适的部分，这里只是要找2014-03-01到2014-03-31的全部事件，而光这些数据的gz文件就有1.26G，同上面那些解压为json文件显得不合适，只能用遍历来处理。

    这里参考了osrc项目中的写法，或者说直接复制过来。

    首先是正规匹配

    1. date_re = re.compile(r"([0-9]{4})-([0-9]{2})-([0-9]{2})-([0-9]+)\.json.gz")

    不过主要的还是在于glob.glob

    glob是python自己带的一个文件操作相关模块，用它可以查找符合自己目的的文件，就类似于Windows下的文件搜索，支持通配符操作。

    这里也就用上了gzip.GzipFile又一个不错的东西。

    最后代码可以见

    github.com/gmszone/ml

    更好的方案？

    Redis

    查询用户事件总数

    1. import redis
    2. r = redis.StrictRedis(host='localhost', port=6379, db=0)
    3. pipe = pipe = r.pipeline()
    4. pipe.zscore('osrc:user',"gmszone")
    5. pipe.execute()

    系统返回了227.0,试试别人。

    1. >>> pipe.zscore('osrc:user',"dfm")
    2. <redis.client.StrictPipeline object at 0x104fa7f50>
    3. >>> pipe.execute()
    4. [425.0]
    5. >>>

    看看主要是在哪一天提交的

    1. >>> pipe.hgetall('osrc:user:gmszone:day')
    2. <redis.client.StrictPipeline object at 0x104fa7f50>
    3. >>> pipe.execute()
    4. [{'1': '51', '0': '41', '3': '17', '2': '34', '5': '28', '4': '22', '6': '34'}]

    结果大致如下图所示:

    SMTWTFS

    看看主要的事件是？

    1. >>> pipe.zrevrange("osrc:user:gmszone:event".format("gmszone"), 0, -1,withscores=True)
    2. <redis.client.StrictPipeline object at 0x104fa7f50>
    3. >>> pipe.execute()
    4. [[('PushEvent', 154.0), ('CreateEvent', 41.0), ('WatchEvent', 18.0), ('GollumEvent', 8.0), ('MemberEvent', 3.0), ('ForkEvent', 2.0), ('ReleaseEvent', 1.0)]]
    5. >>>

    Main Event

    蓝色的就是push事件，黄色的是create等等。

    到这里我们算是知道了OSRC的数据库部分是如何工作的。

    Redis 查询

    主要代码如下所示

    1. def get_vector(user, pipe=None):
    3.     r = redis.StrictRedis(host='localhost', port=6379, db=0)
    4.     no_pipe = False
    5.     if pipe is None:
    6.         pipe = pipe = r.pipeline()
    7.         no_pipe = True
    9.     user = user.lower()
    10.     pipe.zscore(get_format("user"), user)
    11.     pipe.hgetall(get_format("user:{0}:day".format(user)))
    12.     pipe.zrevrange(get_format("user:{0}:event".format(user)), 0, -1,
    13.                    withscores=True)
    14.     pipe.zcard(get_format("user:{0}:contribution".format(user)))
    15.     pipe.zcard(get_format("user:{0}:connection".format(user)))
    16.     pipe.zcard(get_format("user:{0}:repo".format(user)))
    17.     pipe.zcard(get_format("user:{0}:lang".format(user)))
    18.     pipe.zrevrange(get_format("user:{0}:lang".format(user)), 0, -1,
    19.                    withscores=True)
    21.     if no_pipe:
    22.         return pipe.execute()

    结果在上一篇中显示出来了，也就是

    1. [227.0, {'1': '51', '0': '41', '3': '17', '2': '34', '5': '28', '4': '22', '6': '34'}, [('PushEvent', 154.0), ('CreateEvent', 41.0), ('WatchEvent', 18.0), ('GollumEvent', 8.0), ('MemberEvent', 3.0), ('ForkEvent', 2.0), ('ReleaseEvent', 1.0)], 0, 0, 0, 11, [('CSS', 74.0), ('JavaScript', 60.0), ('Ruby', 12.0), ('TeX', 6.0), ('Python', 6.0), ('Java', 5.0), ('C++', 5.0), ('Assembly', 5.0), ('C', 3.0), ('Emacs Lisp', 2.0), ('Arduino', 2.0)]]

    有意思的是在这里生成了和自己相近的人

    1. ['alesdokshanin', 'hjiawei', 'andrewreedy', 'christj6', '1995eaton']

    osrc最有意思的一部分莫过于flann，当然说的也是系统后台的设计的一个很关键及有意思的部分。

    邻近算法与相似用户

    邻近算法是在这个分析过程中一个很有意思的东西。

    邻近算法，或者说K最近邻(kNN，k-NearestNeighbor)分类算法可以说是整个数据挖掘分类技术中最简单的方法了。所谓K最近邻，就是k个最近的邻居的意思，说的是每个样本都可以用她最接近的k个邻居来代表。

    换句话说，我们需要一些样本来当作我们的分析资料，这里东西用到的就是我们之前的。

    1. [227.0, {'1': '51', '0': '41', '3': '17', '2': '34', '5': '28', '4': '22', '6': '34'}, [('PushEvent', 154.0), ('CreateEvent', 41.0), ('WatchEvent', 18.0), ('GollumEvent', 8.0), ('MemberEvent', 3.0), ('ForkEvent', 2.0), ('ReleaseEvent', 1.0)], 0, 0, 0, 11, [('CSS', 74.0), ('JavaScript', 60.0), ('Ruby', 12.0), ('TeX', 6.0), ('Python', 6.0), ('Java', 5.0), ('C++', 5.0), ('Assembly', 5.0), ('C', 3.0), ('Emacs Lisp', 2.0), ('Arduino', 2.0)]]

    在代码中是构建了一个points.h5的文件来分析每个用户的points，之后再记录到hdf5文件中。

    1. [ 0.00438596  0.18061674  0.2246696   0.14977974  0.07488987  0.0969163
    2.     0.12334802  0.14977974  0.          0.18061674  0.          0.          0.
    3.     0.00881057  0.          0.          0.03524229  0.          0.
    4.     0.01321586  0.          0.          0.          0.6784141   0.
    5.     0.07929515  0.00440529  1.          1.          1.          0.08333333
    6.     0.26431718  0.02202643  0.05286344  0.02643172  0.          0.01321586
    7.     0.02202643  0.          0.          0.          0.          0.          0.
    8.     0.          0.          0.00881057  0.          0.          0.          0.
    9.     0.          0.          0.          0.          0.          0.          0.
    10.     0.          0.          0.          0.          0.00881057]

    这里分析到用户的大部分行为，再找到与其行为相近的用户，主要的行为有下面这些:

    • 每星期的情况
    • 事件的类型
    • 贡献的数量，连接以及语言
    • 最多的语言

    osrc中用于解析的代码

    1. def parse_vector(results):
    2.     points = np.zeros(nvector)
    3.     total = int(results[0])
    5.     points[0] = 1.0 / (total + 1)
    7.     # Week means.
    8.     for k, v in results[1].iteritems():
    9.         points[1 + int(k)] = float(v) / total
    11.     # Event types.
    12.     n = 8
    13.     for k, v in results[2]:
    14.         points[n + evttypes.index(k)] = float(v) / total
    16.     # Number of contributions, connections and languages.
    17.     n += nevts
    18.     points[n] = 1.0 / (float(results[3]) + 1)
    19.     points[n + 1] = 1.0 / (float(results[4]) + 1)
    20.     points[n + 2] = 1.0 / (float(results[5]) + 1)
    21.     points[n + 3] = 1.0 / (float(results[6]) + 1)
    23.     # Top languages.
    24.     n += 4
    25.     for k, v in results[7]:
    26.         if k in langs:
    27.             points[n + langs.index(k)] = float(v) / total
    28.         else:
    29.             # Unknown language.
    30.             points[-1] = float(v) / total
    32.     return points

    这样也就返回我们需要的点数，然后我们可以用get_points来获取这些

    1. def get_points(usernames):
    2.     r = redis.StrictRedis(host='localhost', port=6379, db=0)
    3.     pipe = r.pipeline()
    5.     results = get_vector(usernames)
    6.     points = np.zeros([len(usernames), nvector])
    7.     points = parse_vector(results)
    8.     return points

    就会得到我们的相应的数据，接着找找和自己邻近的，看看结果。

    1. [ 0.01298701  0.19736842  0.          0.30263158  0.21052632  0.19736842
    2.     0.          0.09210526  0.          0.22368421  0.01315789  0.          0.
    3.     0.          0.          0.          0.01315789  0.          0.
    4.     0.01315789  0.          0.          0.          0.73684211  0.          0.
    5.     0.          1.          1.          1.          0.2         0.42105263
    6.     0.09210526  0.          0.          0.          0.          0.23684211
    7.     0.          0.          0.03947368  0.          0.          0.          0.
    8.     0.          0.          0.          0.          0.          0.          0.
    9.     0.          0.          0.          0.          0.          0.          0.
    10.     0.          0.          0.          0.        ]

    真看不出来两者有什么相似的地方 。。。。