А. Ю. Долганов - Базовые алгоритмы машинного обучения на языке python

собственных значений
        # берем первые n собственных векторов
        self.components = eigenvectors[:, idx][:, :self.n_components]
        self.values     = eigenvalues[idx] # отсортированные собственные значения
        return self
    #-------------------------------    def transform(self, X):
        # преобразование признаков в пространство главных компонент
        X = X - self.mean #вычитаем среднее

118

6. Класс уменьшения размерности методом главных компонент

        return np.dot(X, self.components) #находим проекции признаков на собственные вектора (через скалярное произведение)
        #это и будут главные компоненты
    #-------------------------------    def fit_transform(self, X):
        # 2 в 1: обучаем и преобразуем
        return self.fit(X).transform(X)
    #-------------------------------    def inverse_transform(self, X_new):
        # обратное преобразование
        # главные компоненты скалярно домножаем на собственные вектора
        return np.dot(X_new, self.components.T) + self.mean # не забываем обратно добавить среднее
    #-------------------------------    def score(self, X):
        # оцека «качества» восстановления - через коэффициент детерминации
        SStot = np.sum(np.square(X - np.mean(X)))
        SSres = np.sum(np.square(X - self.inverse_transform(self.
fit_transform(X))))
        return 1 - SSres/SStot
    #-------------------------------    def plot_eigvalues(self, figsize=(15,7)):
        # метод для отрисовки собственных значений (объясненной дисперсии)
plt.figure(figsize=figsize)
        # отдельно мелкими точками визуализируем все собственные значения
        plt.plot(self.values,’.’,
                 label=’Все собственные значения’,
                 linewidth = 3)
        # крупными маркерами - выбранное нами количество главных компонент
        plt.plot(self.values[:self.n_components],’r-o’,
                 label=’Собственное пространство’,
                 markersize = 10, mfc=’none’,
                 linewidth = 2, alpha = 0.8)
        plt.ylabel(‘Собственные\n значения’, fontsize=25)
        plt.grid();

119

ПРИЛОЖЕНИЯ

        plt.legend(fontsize=25);
        plt.xticks(FontSize = 25); plt.yticks(FontSize = 25);
        plt.tight_layout();      

7. Класс кластеризации методом k-средних
import numpy as np
class KMeans():
    def __init__(self,n_clusters = 2, centroids = None,
                 max_iter=10, tol=0.01,
                 metric = ‘euclidean’, p = 2,
                 random_state = None):
        self.n_clusters = n_clusters
        self.centroids  = centroids
        self.max_iter   = max_iter        
        self.tol        = tol
        self.iters      = None
        self.inertia = None
        self.metric = metric
        self.p  = p
        self.random_state  = random_state
    #-------------------------------------    
    def distance(self,X1, X2):
        # оценка расстояния
        if self.metric == ‘euclidean’:
            dist = np.sqrt(np.sum(np.square(X1 - X2).T,axis=0))
        if self.metric == ‘cityblock’:
            dist = np.sum(np.abs(X1 - X2).T,axis=0)
        if self.metric == ‘Chebyshev’:
            dist = np.max(np.abs(X1 - X2).T,axis=0)  
        if self.metric == ‘Minkowski’:
            dist = np.power(np.sum(np.power(np.abs(X1 - X2),self.p).T,axis=0),1/self.p)      
        return dist
    #------------------------------------    def init_centroids(self, X):
        # инициализация первых центров кластеров

120

7. Класс кластеризации методом k-средних

        if self.random_state: rng = np.random.seed(self.random_state)
        c_idxs = np.random.randint(0, X.shape[0], size = self.n_clusters)
        return X[c_idxs,:]
    #------------------------------------    def predict(self, X):
        # оценка принадлежности точек к кластеру по расстоянию
        distances = np.zeros((X.shape[0], self.n_clusters))
        for i,centr in enumerate(self.centroids):
            distances[:,i] = self.distance(centr,X)
        self.inertia = np.sum(np.power(np.min(distances,axis = 1),2))
        return np.argmin(distances,axis = 1)
    #------------------------------------    def transform(self,X):
        # получение предсказаний
        return self.predict(X)
    #------------------------------------    def delta_centroids(self,old_centroids):
        # оценка относительного изменения центров кластеров
        return (
                self.distance(self.centroids,old_centroids)/
                self.distance(old_centroids, np.mean(old_centroids))
               ).mean()
    #------------------------------------    def fit(self, X):
        # обучение - несколько итераций алгоритма k-средних
        if self.centroids is None: # если центры кластеров не заданы - задаем
            self.centroids = self.init_centroids(X)
    
        d_centrs = np.inf
        for i in range(self.max_iter):
            old_centroids = np.copy(self.centroids)
            
            cluster_label = self.predict(X)
            for k in range(self.n_clusters):
                

121

ПРИЛОЖЕНИЯ

c_idxs = np.flatnonzero(cluster_label==k)
                
                self.centroids[k] = X[c_idxs].mean(axis = 0)
            d_centrs = self.delta_centroids(old_centroids)
            self.iters = i
            if d_centrs --">