NBA控卫聚类——K-Means详解

Dataset

在NBA的媒体报道,体育记者通常集中在少数几个球员。由于我们的数据科学的帽子,我们不禁感到一阵怀疑为什么这个球员与其他球员不一样。那么就使用数据科学进一步探索该这个问题。 本文的数据集nba_2013.csv是2013 - 2014赛季的NBA球员的表现。

• player – name of the player(名字)
• pos – the position of the player（位置）
• g – number of games the player was in（参赛场数）
• pts – total points the player scored（总得分）
• fg. – field goal percentage（投篮命中率）
• ft. – free throw percentage（罚球命中率）

import pandas as pd
import numpy as np

nba = pd.read_csv("nba_2013.csv")
nba.head(3)
‘‘‘
         player pos  age bref_team_id   g  gs    mp   fg  fga    fg.  \
0    Quincy Acy  SF   23          TOT  63   0   847   66  141  0.468   
1  Steven Adams   C   20          OKC  81  20  1197   93  185  0.503   
2   Jeff Adrien  PF   27          TOT  53  12   961  143  275  0.520   

      ...      drb  trb  ast  stl  blk  tov   pf  pts     season  season_end  
0     ...      144  216   28   23   26   30  122  171  2013-2014        2013  
1     ...      190  332   43   40   57   71  203  265  2013-2014        2013  
2     ...      204  306   38   24   36   39  108  362  2013-2014        2013  

[3 rows x 31 columns]
‘‘‘

Point Guards

控球后卫(Point Guards)往往是全队进攻的组织者，并通过对球的控制来决定在恰当的时间传球给适合的球员，是球场上拿球机会最多的人。他要把球从后场安全地带到前场，再把球传给其他队友，这才有让其他人得分的机会。 一个合格的控球后卫必须要能够在只有一个人防守他的情况下，毫无问题地将球带过半场。然后，他还要有很好的传球能力，能够在大多数的时间里，将球传到球应该要到的地方：有时候是一个可以投篮的空档，有时候是一个更好的导球位置。

• 先提取出所有控卫的球员信息：

point_guards = nba[nba[‘pos‘] == ‘PG‘]

Points Per Game

• 由于我们的数据集给出的是球员的总得分（pts）以及参赛场数(g)，没有直接给出每场球赛的平均得分(Points Per Game)，但是可以根据前两个值计算：

point_guards[‘ppg‘] = point_guards[‘pts‘] / point_guards[‘g‘]

# Sanity check, make sure ppg = pts/g
point_guards[[‘pts‘, ‘g‘, ‘ppg‘]].head(5)
‘‘‘
    pts   g        ppg
24  930  71  13.098592
29  150  20   7.500000
30  660  79   8.354430
38  666  72   9.250000
50  378  55   6.872727
‘‘‘

Assist Turnover Ratio

NBA中专门有一项数据统计叫assist/turnover，是用这个队员助攻数比上他的失误数，这项统计能准确的反映一个控卫是否称职。

• 助攻失误比的计算公式如下，其中Assists表示总助攻（ast），Turnovers表示总失误(tov)。

• 计算之前要将那些失误率为0的球员去掉，一是因为他可能参赛数很少，分析他没有意义，而来作为除数不能为0.

point_guards = point_guards[point_guards[‘tov‘] != 0]
point_guards[‘atr‘] = point_guards[‘ast‘] / point_guards[‘tov‘]

Visualizing The Point Guards

• 可视化控卫的信息，X轴表示的是个平均每场球赛的得分，Y轴是助攻失误比。

plt.scatter(point_guards[‘ppg‘], point_guards[‘atr‘], c=‘y‘)
plt.title("Point Guards")
plt.xlabel(‘Points Per Game‘, fontsize=13)
plt.ylabel(‘Assist Turnover Ratio‘, fontsize=13)

Clustering Players

• 粗略看一下上面的图，大约有五簇比较集中。可以利用聚类技术将相同的控卫聚集在一组。KMeans是比较常用的聚类算法，是基于质心的聚类（簇是一个圆圈，质心是这个簇的平均向量）。将K设置为5.在美国议员党派——K均值聚类
  这篇文章中我们也用到KMeans这个算法，当时我们是直接调用sklearn中的包（from sklearn.cluster import KMeans），然后直接计算。但是在本文，我们想要研究KMeans的具体步骤，因此一步步迭代。

kmeans_model = KMeans(n_clusters=2, random_state=1)
senator_distances = kmeans_model.fit_transform(votes.iloc[:, 3:])

Step 1

• 首先随机生成5个中心点：

num_clusters = 5
# Use numpy‘s random function to generate a list, length: num_clusters, of indices
random_initial_points = np.random.choice(point_guards.index, size=num_clusters)
# Use the random indices to create the centroids
centroids = point_guards.ix[random_initial_points]

• 可视化初始聚类中心，其中中心点用红色标识，其他的点用黄色标识：

plt.scatter(point_guards[‘ppg‘], point_guards[‘atr‘], c=‘yellow‘)
plt.scatter(centroids[‘ppg‘], centroids[‘atr‘], c=‘red‘)
plt.title("Centroids")
plt.xlabel(‘Points Per Game‘, fontsize=13)
plt.ylabel(‘Assist Turnover Ratio‘, fontsize=13)

• 然后将中心点转化为一个字典格式，字典的键是这个簇的名称，字典的值是这个中心点的信息（”ppg”,”atr”）。

def centroids_to_dict(centroids):
    dictionary = dict()
    # iterating counter we use to generate a cluster_id
    counter = 0

    # iterate a pandas data frame row-wise using .iterrows()
    for index, row in centroids.iterrows():
        coordinates = [row[‘ppg‘], row[‘atr‘]] #list对象
        dictionary[counter] = coordinates
        counter += 1

    return dictionary

centroids_dict = centroids_to_dict(centroids)

• 再然后就是计算每个点到聚类中心的距离然后将每个点的聚类中心修改为离其最近的那个簇。

import math
# 计算两个点距离的函数
def calculate_distance(centroid, player_values): # 参数都是list对象
    root_distance = 0    
    for x in range(0, len(centroid)):
        difference = centroid[x] - player_values[x]
        squared_difference = difference**2
        root_distance += squared_difference

    euclid_distance = math.sqrt(root_distance)
    return euclid_distance
# 返回离每个点最近的簇的键
def assign_to_cluster(row):
    lowest_distance = -1
    closest_cluster = -1  
    for cluster_id, centroid in centroids_dict.items():
        df_row = [row[‘ppg‘], row[‘atr‘]]
        euclidean_distance = calculate_distance(centroid, df_row)

        if lowest_distance == -1:
            lowest_distance = euclidean_distance
            closest_cluster = cluster_id 
        elif euclidean_distance < lowest_distance:
            lowest_distance = euclidean_distance
            closest_cluster = cluster_id
    return closest_cluster

# 生成一个新的属性：存储每个节点的簇号
point_guards[‘cluster‘] = point_guards.apply(lambda row: assign_to_cluster(row), axis=1)

• 可视化第一次迭代的聚类图，将不同的簇用不同的颜色表示出来：

def visualize_clusters(df, num_clusters):
    colors = [‘b‘, ‘g‘, ‘r‘, ‘c‘, ‘m‘, ‘y‘, ‘k‘]

    for n in range(num_clusters):
        clustered_df = df[df[‘cluster‘] == n]
        plt.scatter(clustered_df[‘ppg‘], clustered_df[‘atr‘], c=colors[n-1])
        plt.xlabel(‘Points Per Game‘, fontsize=13)
        plt.ylabel(‘Assist Turnover Ratio‘, fontsize=13)

visualize_clusters(point_guards, 5)

Step 2

• 将所有节点聚集后，开始重新计算每个簇的质点：

def recalculate_centroids(df):
    new_centroids_dict = dict()

    for cluster_id in range(0, num_clusters):
        values_in_cluster = df[df[‘cluster‘] == cluster_id]
        # Calculate new centroid using mean of values in the cluster
        new_centroid = [np.average(values_in_cluster[‘ppg‘]), np.average(values_in_cluster[‘atr‘])]
        new_centroids_dict[cluster_id] = new_centroid
    return new_centroids_dict

centroids_dict = recalculate_centroids(point_guards)

Repeat Step 1

• 然后重复第一步中的，将所有节点重新分给离其最近的那个簇中（跟1相差不大）：

point_guards[‘cluster‘] = point_guards.apply(lambda row: assign_to_cluster(row), axis=1)
visualize_clusters(point_guards, num_clusters)

Repeat Step 2 And Step 1

centroids_dict = recalculate_centroids(point_guards)
point_guards[‘cluster‘] = point_guards.apply(lambda row: assign_to_cluster(row), axis=1)
visualize_clusters(point_guards, num_clusters)

Challenges Of K-Means

观察前几次迭代，每次节点改变都不是很大，主要是因为：

• K-Means算法在迭代的过程中，对于每个簇不会引起很大的变化，因此这个算法总是收敛的并且很稳定。
• 由于K-Means算法迭代得很保守，因此最终结果与选取的初始质点有很大关系。

为了解决这些问题，sklearn包中的K-Means实现中做了一些智能的功能，比如重复聚类，每次随机选取质心，这比只采用一次质心选取所带来的偏差要少很多。

from sklearn.cluster import KMeans

kmeans = KMeans(n_clusters=num_clusters)
kmeans.fit(point_guards[[‘ppg‘, ‘atr‘]])
point_guards[‘cluster‘] = kmeans.labels_

visualize_clusters(point_guards, num_clusters)