Generalized classification algorithm

 В машинном обучении обобщение — это определение, демонстрирующее, насколько хорошо обученная модель может классифицировать или прогнозировать невидимые данные. Обучение обобщенной модели машинного обучения, как правило, означает, что она работает для всего подмножества невидимых данных. Например, когда мы обучаем модель классифицировать собак и кошек. Если модель снабжена набором данных изображений собак только с двумя породами, она может получить хорошую производительность. Но, возможно, он получит низкий классификационный балл при тестировании на других породах собак. Эта проблема может привести к тому, что фактическое изображение собаки будет классифицировано как кошка из невидимого набора данных. Поэтому разнообразие данных является очень важным фактором для того, чтобы сделать хороший прогноз. В приведенном выше примере модель может получить 85% баллов, если ее тестируют только две породы собак, и 70%, если ее тренируют все породы. Тем не менее, первый, возможно, получит очень низкий балл (например, 45%), если он оценивается невидимым набором данных для собак всех пород. Для последнего варианта это может быть неизменным преимуществом , учитывая, что он был обучен большим разнообразием данных, включая все возможные породы.

Следует принимать во внимание, что разнообразие данных - не единственный момент, который необходимо учитывать для получения обобщенной модели. Это может быть связано с характером алгоритма машинного обучения или плохой конфигурацией гиперпараметров. 

Есть несколько методов (регуляризация), которые можно применять во время обучения модели, чтобы обеспечить обобщение. 

========================================

Определяющие факторы для обучения обобщенных моделей.Существуют разные способы обеспечить обобщение модели машинного обучения. 

1.Набор данных

Для обучения классификатора и создания обобщенной модели машинного обучения используемый набор данных должен содержать разнообразие. Следует отметить, что это не означает огромный набор данных, а набор данных, содержащий все разные выборки. Это помогает обучать классификатор не только на конкретном подмножестве данных и, следовательно, лучше выполнять обобщение. Кроме того, во время обучения рекомендуется использовать методы перекрестной проверки, такие как перекрестная проверка K-fold или Монте-Карло. Эти методы более безопасны для использования всех возможных частей данных и позволяют избежать создания модели переобучения.

2.Алгоритм машинного обучения

Алгоритмы машинного обучения по-разному действуют против переобучения, недообучения. Переобучение более вероятно с нелинейными, непараметрическими алгоритмами машинного обучения. Например, Decision Tree - это непараметрический алгоритм машинного обучения, то есть его модель с большей вероятностью переобучается. С другой стороны, некоторые модели машинного обучения слишком просты, чтобы фиксировать в данных сложные закономерности. Это приводит к построению неподходящей модели. Примерами являются линейная и логистическая регрессия.

3.Сложность модели

Когда модели машинного обучения становятся слишком сложными, они обычно склонны к переобучению. Существуют методы, помогающие упростить модель. Они называются методами регуляризации. 

4.Регуляризация

Регуляризация — это набор методов, упрощающих модель машинного обучения. С этой целью к различным алгоритмам машинного обучения применяются определенные подходы, например, обрезка для деревьев решений, методы отсева для нейронных сетей и добавление параметров штрафа к функции стоимости в регрессии.

A classification example using Generalized Additive Models with pyGAM (https://www.kaggle.com/ )

Original csv files don't match register and names placed in python and require to be fixed up to be loaded via pandas into dataframes

(.env) boris@boris-All-Series:~/GENERALIZEDCLASS$ cat generalClass.py

import pandas  as pd

import matplotlib.pyplot as plt

from pygam import LogisticGAM, s, f

train_data = pd.read_csv('titanic_train.csv')

test_data  = pd.read_csv('titanic_test.csv')

features = ["pclass", "sex", "sibsp", "parch"]

X_train       = pd.get_dummies(train_data[features])

y_train       = train_data["survived"]

final_X_test  = pd.get_dummies(test_data[features])

classifier = LogisticGAM(s(0) + s(1) + s(2) + s(3))

classifier.fit(X_train, y_train)

predictions = classifier.predict(final_X_test)

# convert from True/False to 1/0

predictions = (predictions)*1

classifier.summary()

plt.figure(figsize=(15, 4))

for i, term in enumerate(classifier.terms):

    if term.isintercept:

        continue

    plt.plot(classifier.partial_dependence(term=i), label="s({})".format(i))

    plt.legend()

plt.draw()

output = pd.DataFrame({'passenger_id': test_data.passenger_id, 'survived': predictions})

output.to_csv('submission.csv', index=False)

plt.show()

(.env) boris@boris-All-Series:~/GENERALIZEDCLASS$ python3 generalClass.py

LogisticGAM                                                                                               

=========================================== 

Distribution:                      BinomialDist Effective DoF:                                     11.4841

Link Function:                        LogitLink Log Likelihood:                                  -390.4633

Number of Samples:              850 AIC: 803.8948                                                                                                 AICc:   804.2972

                                                UBRE:  2.9566

                                                Scale:    1.0

                                                Pseudo R-Squared:  0.3019                  =================================

Feature Function                  Lambda               Rank         EDoF         P > x        Sig. Code   

============================================= 

s(0)                              [0.6]                20           3.5          1.34e-10     ***         

s(1)                              [0.6]                20           4.1          2.51e-02     *           

s(2)                              [0.6]                20           3.2          4.98e-03     **          

s(3)                              [0.6]                20           0.8          0.00e+00     ***         

intercept                                              1            0.0          3.43e-02     *           

============================================

Significance codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

WARNING: Fitting splines and a linear function to a feature introduces a model identifiability problem

         which can cause p-values to appear significant when they are not.

WARNING: p-values calculated in this manner behave correctly for un-penalized models or models with

         known smoothing parameters, but when smoothing parameters have been estimated, the p-values

         are typically lower than they should be, meaning that the tests reject the null too readily.

/home/boris/GENERALIZEDCLASS/generalClass.py:22: UserWarning: KNOWN BUG: p-values computed in this summary are likely much smaller than they should be. 

 

Please do not make inferences based on these values! 

Collaborate on a solution, and stay up to date at: 

github.com/dswah/pyGAM/issues/163 

  classifier.summary()

Второй пример

(.env) boris@boris-All-Series:~/GENERALIZEDCLASS$ cat testLogisticGAM1.py

from pygam import LogisticGAM, s, f

from pygam.datasets import default

import matplotlib.pyplot as plt

X, y = default(return_X_y=True)

gam = LogisticGAM(f(0) + s(1) + s(2)).gridsearch(X, y)

fig, axs = plt.subplots(1, 3)

titles = ['student', 'balance', 'income']

for i, ax in enumerate(axs):

    XX = gam.generate_X_grid(term=i)

    pdep, confi = gam.partial_dependence(term=i, width=.95)

    ax.plot(XX[:, i], pdep)

    ax.plot(XX[:, i], confi, c='r', ls='--')

    ax.set_title(titles[i]);

plt.draw()

gam.accuracy(X, y)

gam.summary()

plt.show()

(.env) boris@boris-All-Series:~/GENERALIZEDCLASS$ python3 testLogisticGAM1.py

100% (11 of 11) |######################################################| Elapsed Time: 0:00:02 Time:  0:00:02

LogisticGAM                                                                                               

============================================ 

Distribution:                      BinomialDist Effective DoF:                                      3.8047

Link Function:                        LogitLink Log Likelihood:                                   -788.877

Number of Samples:                        10000 AIC:                                             1585.3634

                                                AICc:                                             1585.369

                                                UBRE:                                               2.1588

                                                Scale:                                                 1.0

                                                Pseudo R-Squared:                                   0.4598

=============================================

Feature Function                  Lambda               Rank         EDoF         P > x        Sig. Code   

=============================================

f(0)                              [1000.]              2            1.7          4.61e-03     **          

s(1)                              [1000.]              20           1.2          0.00e+00     ***         

s(2)                              [1000.]              20           0.8          3.29e-02     *           

intercept                                              1            0.0          0.00e+00     ***         

=============================================

Significance codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

WARNING: Fitting splines and a linear function to a feature introduces a model identifiability problem

         which can cause p-values to appear significant when they are not.

WARNING: p-values calculated in this manner behave correctly for un-penalized models or models with

         known smoothing parameters, but when smoothing parameters have been estimated, the p-values

         are typically lower than they should be, meaning that the tests reject the null too readily.

/home/boris/GENERALIZEDCLASS/testLogisticGAM1.py:22: UserWarning: KNOWN BUG: p-values computed in this summary are likely much smaller than they should be. 

 

Please do not make inferences based on these values! 

Collaborate on a solution, and stay up to date at: 

github.com/dswah/pyGAM/issues/163 

  gam.summary()

Третий пример

(.env) boris@boris-All-Series:~/GENERALIZEDCLASS$ cat testLogisticGAM3.py

import pandas as pd        

from pygam import LogisticGAM

from sklearn.datasets import load_breast_cancer

import matplotlib.pyplot as plt

from sklearn.metrics import accuracy_score

from sklearn.metrics import log_loss

import numpy as np

from sklearn.model_selection import train_test_split

#load the breast cancer data set

data = load_breast_cancer()

#keep first 6 features only

df = pd.DataFrame(data.data, columns=data.feature_names)[['mean radius', 'mean texture', 'mean perimeter', 'mean area','mean smoothness', 'mean compactness']]

target_df = pd.Series(data.target)

print(df.describe())

X = df[['mean radius', 'mean texture', 'mean perimeter', 'mean area', \

             'mean smoothness', 'mean compactness']]

y = target_df

lambda_ = [0.6, 0.6, 0.6, 0.6, 0.6, 0.6]

n_splines = [4, 14, 4, 6, 12, 12] 

constraints = [None, None, None, None, None, None]

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)

gam = LogisticGAM(constraints=constraints, 

                  lam=lambda_,

                  n_splines=n_splines).fit(X_train, y_train)

predictions = gam.predict(X_test)

print("Accuracy: {} ".format(accuracy_score(y_test, predictions)))

probas = gam.predict_proba(X_test)      

print("Log Loss: {} ".format(log_loss(y_test, probas)))

gam.summary()

plt.rcParams['figure.figsize'] = (28, 8)

fig, axs = plt.subplots(1, len(data.feature_names[0:6]))

titles = data.feature_names

for i, ax in enumerate(axs):

    XX = gam.generate_X_grid(term=i)

    pdep, confi = gam.partial_dependence(term=i , width=.95)

    ax.plot(XX[:, i], pdep)

    ax.plot(XX[:, i], confi, c='grey', ls='--')

    ax.set_title(titles[i])

plt.show()

(.env) boris@boris-All-Series:~/GENERALIZEDCLASS$ python3 testLogisticGAM3.py

       mean radius  mean texture  ...  mean smoothness  mean compactness

count   569.000000    569.000000  ...       569.000000        569.000000

mean     14.127292     19.289649  ...         0.096360          0.104341

std       3.524049      4.301036  ...         0.014064          0.052813

min       6.981000      9.710000  ...         0.052630          0.019380

25%      11.700000     16.170000  ...         0.086370          0.064920

50%      13.370000     18.840000  ...         0.095870          0.092630

75%      15.780000     21.800000  ...         0.105300          0.130400

max      28.110000     39.280000  ...         0.163400          0.345400

[8 rows x 6 columns]

Accuracy: 0.9680851063829787 

Log Loss: 0.10707673143908972

LogisticGAM                                                                                               

==========================================

Distribution:                      BinomialDist Effective DoF:                                     12.8118

Link Function:                        LogitLink Log Likelihood:                                   -51.4609

Number of Samples:                          381 AIC:                                              128.5454

                                                AICc:                                             129.6627

                                                UBRE:                                               2.3643

                                                Scale:                                                 1.0

                                                Pseudo R-Squared:                                   0.7967

=========================================

Feature Function                  Lambda               Rank         EDoF         P > x        Sig. Code   

=========================================

s(0)                              [0.6]                4            3.0          1.61e-06     ***         

s(1)                              [0.6]                14           3.8          1.06e-03     **          

s(2)                              [0.6]                4            1.3          4.19e-05     ***         

s(3)                              [0.6]                6            0.7          0.00e+00     ***         

s(4)                              [0.6]                12           2.6          1.06e-02     *           

s(5)                              [0.6]                12           1.5          1.59e-01                 

intercept                                              1            0.0          7.66e-04     ***         

=========================================

Significance codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

WARNING: Fitting splines and a linear function to a feature introduces a model identifiability problem

         which can cause p-values to appear significant when they are not.

WARNING: p-values calculated in this manner behave correctly for un-penalized models or models with

         known smoothing parameters, but when smoothing parameters have been estimated, the p-values

         are typically lower than they should be, meaning that the tests reject the null too readily.

/home/boris/GENERALIZEDCLASS/testLogisticGAM3.py:36: UserWarning: KNOWN BUG: p-values computed in this summary are likely much smaller than they should be. 

 

Please do not make inferences based on these values! 

Collaborate on a solution, and stay up to date at: 

github.com/dswah/pyGAM/issues/163 

  gam.summary()

 

skmultiflow.data.SEAGenerator

 Генератор потока SEA.

Этот генератор представляет собой реализацию потока данных с резким дрейфом концепции, впервые описанную Стритом и Кимом в «Алгоритме потокового ансамбля (SEA) для крупномасштабной классификации». Он генерирует 3 числовых атрибута, которые варьируются от 0 до 10, где только 2 из них имеют отношение к задаче классификации. Выбирается классификационная функция из четырех возможных. Эти функции сравнивают сумму двух релевантных атрибутов с пороговым значением, уникальным для каждой из функций классификации. В зависимости от сравнения генератор классифицирует экземпляр как одну из двух возможных меток.

Дрейф концепции можно ввести, изменив функцию классификации. Это можно сделать вручную или с помощью ConceptDriftStream.

Этот поток данных имеет два дополнительных параметра, первый — балансировать классы, что означает, что распределение классов будет стремиться к равномерному, и возможность добавления шума, который с некоторой вероятностью изменит выбранную метку для экземпляра.

Параметры

Функция_классификации: int (по умолчанию: 0). Какую из четырех функций классификации использовать для генерации - это значение может варьироваться от 0 до 3, а пороговые значения: 8, 9, 7 и 9,5. random_state: int, экземпляр RandomState или None, необязательно (по умолчанию = None)

Random_state: int, экземпляр RandomState или None, необязательно (по умолчанию = None)

Если int, random_state — это начальное число, используемое генератором случайных чисел; 

Если экземпляр RandomState, random_state является генератором случайных чисел; 

Если None,генератором случайных чисел является экземпляр RandomState, используемый np.random.

Балансировать классы или нет. Если сбалансировано, распределение классов будет сходиться к равномерному распределению. Noise_percentage: число с плавающей запятой (по умолчанию: 0,0)

Вероятность появления шума в генерации. При каждой новой сгенерированной выборке генерируется случайная вероятность, и если эта вероятность выше, чем уровень шума, выбранная метка будет переключена. От 0,0 до 1,0.

(.env) boris@boris-All-Series:~/RANDOMSEARCH$ cat seaGenerator.py

from skmultiflow.data import SEAGenerator

from skmultiflow.evaluation import EvaluatePrequential

from skmultiflow.trees import  HoeffdingTreeClassifier

import matplotlib.pyplot as plt

import warnings

warnings.filterwarnings("ignore")

stream = SEAGenerator()      # create a stream

stream.prepare_for_use()     # prepare the stream for use

X,Y = stream.next_sample()

tree = HoeffdingTreeClassifier()

nb_iters = 30000

correctness_dist = []

for i in range(nb_iters):

   X, Y = stream.next_sample()        # get the next sample

   prediction = tree.predict(X)       # predict Y using the tree     

   if Y == prediction:                # check the prediction

     correctness_dist.append(1)

   else:

     correctness_dist.append(0)   

   tree.partial_fit(X, Y)             # update the tree

time = [i for i in range(1, nb_iters)]

accuracy = [sum(correctness_dist[:i])/len(correctness_dist[:i]) \

                                      for i in range(1, nb_iters)]

plt.plot(time, accuracy)

evaluator=EvaluatePrequential(show_plot=True,pretrain_size=200,max_samples=nb_iters)

evaluator.evaluate(stream=stream, model=tree)

Setup scikit-multiflow Python 3.10.4 && Plotting

 Чистый случайный поиск выбирает точки из домена независимо, и целевая функция не влияет на метод генерации следующей точки выборки. Напротив, чистый адаптивный поиск выбирает следующую точку из подмножества области со строго превосходящими значениями целевой функции. Чистый случайный поиск является экстремальным в том смысле, что итерации полностью независимы и никогда не используют предыдущую информацию для воздействия на стратегию поиска, в то время как чистый адаптивный поиск является экстремальным в противоположном смысле, потому что итерации полностью зависят друг от друга, а стратегия поиска заставляет улучшаться. по определению.

Три наиболее важных аспекта Adaptive Random Forest: 

(1) создание разнообразия путем повторной выборки; 

(2) создание разнообразия путем случайного выбора подмножеств признаков для разделения узлов; 

(3) детекторы дрейфа на базовое дерево, которые вызывают выборочный сброс в ответ на дрейф. Это также позволяет обучать фоновые деревья, которые начинают обучение при обнаружении предупреждения и заменяют активное дерево, если предупреждение переходит в дрейф.

(.env) boris@boris-All-Series:~/RANDOMSEARCH$ pip install -U numpy

(.env) boris@boris-All-Series:~/RANDOMSEARCH$ pip install -U Cython

(.env) boris@boris-All-Series:~/RANDOMSEARCH$ pip install -U git+https://github.com/scikit-multiflow/scikit-multiflow

(.env) boris@boris-All-Series:~/RANDOMSEARCH$ cat randomSearch3.py

from skmultiflow.data import RegressionGenerator

from skmultiflow.meta import AdaptiveRandomForestRegressor

import numpy as np

# creating n distributions

df= np.random.normal(3, 0, size=(30, 3))

for i in range(30):

    df2= np.random.normal(3, i+1, size=(30, 3))

    df= np.vstack([df, df2])

import matplotlib.pyplot as plt

plt.plot(df[:,0])

plt.show() # plotting for 1 col only

# Setup the Adaptive Random Forest regressor

arf_reg = AdaptiveRandomForestRegressor(random_state=123456)

# Run test-then-train loop for max_samples and while there is data

y_pred=[]

for i in range(500):

    

    X=df[i,0:2].reshape(1,2)

    y=df[i,2].reshape(1)

    

    y_pred.append(arf_reg.predict(X)[0])

    arf_reg.partial_fit(X, y)

y_true = list(df[:500,2].reshape(500,))

# Display results

print('Adaptive Random Forest regressor example')

print('Mean absolute error: {}'.format(np.mean(np.abs(np.array(y_true) - np.array(y_pred)))))

y_true= np.array(y_true).reshape(500,)

data_for_plot= np.abs(y_true - y_pred)

plt.plot(data_for_plot)

plt.title('performace on continious model retraining')

plt.ylabel('error-prediction')

plt.show()

Setup scikit-multiflow Python 3.10.4

Чистый случайный поиск выбирает точки из домена независимо, и целевая функция не влияет на метод генерации следующей точки выборки. Напротив, чистый адаптивный поиск выбирает следующую точку из подмножества области со строго превосходящими значениями целевой функции. Чистый случайный поиск является экстремальным в том смысле, что итерации полностью независимы и никогда не используют предыдущую информацию для воздействия на стратегию поиска, в то время как чистый адаптивный поиск является экстремальным в противоположном смысле, потому что итерации полностью зависят друг от друга, а стратегия поиска заставляет улучшаться. по определению.

Три наиболее важных аспекта Adaptive Random Forest: 

(1) создание разнообразия путем повторной выборки; 

(2) создание разнообразия путем случайного выбора подмножеств признаков для разделения узлов; 

(3) детекторы дрейфа на базовое дерево, которые вызывают выборочный сброс в ответ на дрейф. Это также позволяет обучать фоновые деревья, которые начинают обучение при обнаружении предупреждения и заменяют активное дерево, если предупреждение переходит в дрейф.

(.env) boris@boris-All-Series:~/RANDOMSEARCH$ pip install -U numpy

(.env) boris@boris-All-Series:~/RANDOMSEARCH$ pip install -U Cython

(.env) boris@boris-All-Series:~/RANDOMSEARCH$ pip install -U git+https://github.com/scikit-multiflow/scikit-multiflow

(.env) boris@boris-All-Series:~/RANDOMSEARCH$ cat randomSearch.py

# Imports

from skmultiflow.data import RegressionGenerator

from skmultiflow.meta import AdaptiveRandomForestRegressor

import numpy as np

# Setup a data stream

stream = RegressionGenerator(random_state=1, n_samples=500)

# Prepare stream for use

# Setup the Adaptive Random Forest regressor

arf_reg = AdaptiveRandomForestRegressor(random_state=123456)

# Auxiliary variables to control loop and track performance

n_samples = 0

max_samples = 500

y_pred = np.zeros(max_samples)

y_true = np.zeros(max_samples)

# Run test-then-train loop for max_samples and while there is data

while n_samples < max_samples and stream.has_more_samples():

    X, y = stream.next_sample()

    y_true[n_samples] = y[0]

    y_pred[n_samples] = arf_reg.predict(X)[0]

    arf_reg.partial_fit(X, y)

    n_samples += 1

# Display results

print('Adaptive Random Forest regressor example')

print('{} samples analyzed.'.format(n_samples))

print('Mean absolute error: {}'.format(np.mean(np.abs(y_true - y_pred))))

(.env) boris@boris-All-Series:~/RANDOMSEARCH$ python3 randomSearch.py

Adaptive Random Forest regressor example

500 samples analyzed.

Mean absolute error: 136.54102745501535

n_samples = 1000

max_samples = 1000

(.env) boris@boris-All-Series:~/RANDOMSEARCH$ cat randomSearch3.py

from skmultiflow.data import RegressionGenerator

from skmultiflow.meta import AdaptiveRandomForestRegressor

import numpy as np

# creating n distributions

df= np.random.normal(3, 0, size=(30, 3))

for i in range(30):

    df2= np.random.normal(3, i+1, size=(30, 3))

    df= np.vstack([df, df2])

import matplotlib.pyplot as plt

plt.plot(df[:,0])

plt.show() # plotting for 1 col only

# Setup the Adaptive Random Forest regressor

arf_reg = AdaptiveRandomForestRegressor(random_state=123456)

# Run test-then-train loop for max_samples and while there is data

y_pred=[]

for i in range(500):

    

    X=df[i,0:2].reshape(1,2)

    y=df[i,2].reshape(1)

    

    y_pred.append(arf_reg.predict(X)[0])

    arf_reg.partial_fit(X, y)

y_true = list(df[:500,2].reshape(500,))

# Display results

print('Adaptive Random Forest regressor example')

print('Mean absolute error: {}'.format(np.mean(np.abs(np.array(y_true) - np.array(y_pred)))))

y_true= np.array(y_true).reshape(500,)

data_for_plot= np.abs(y_true - y_pred)

plt.plot(data_for_plot)

plt.title('performace on continious model retraining')

plt.ylabel('error-prediction')

plt.show()

How to Merge Two Pandas DataFrames on Index

Функция join() по умолчанию выполняет левое соединение, поэтому каждый из индексов в первом кадре данных сохраняется.

Функция merge() по умолчанию выполняет внутреннее соединение, поэтому сохраняются только те индексы, которые появляются в обоих кадрах данных.

Функция concat() по умолчанию выполняет внешнее соединение, поэтому сохраняется каждое значение индекса из каждого кадра данных.

(.env) boris@boris-All-Series:~/VALUEPY$ cat mergePandas.py

import pandas as pd

#create first DataFrame

df1 = pd.DataFrame({'rating': [90, 85, 82, 88, 94, 90, 76, 75],

                   'points': [25, 20, 14, 16, 27, 20, 12, 15]},

                   index=list('abcdefgh'))

print(df1)

#create second DataFrame 

df2 = pd.DataFrame({'assists': [5, 7, 7, 8, 5, 7],

                   'rebounds': [11, 8, 10, 6, 6, 9]},

                   index=list('acdgmn'))           

print(df2)

# Merge DataFrames Using Join

print("Merge DataFrames Using Join")

print(df1.join(df2))

# Merge DataFrames Using Merge

print("Merge DataFrames Using Merge")

print(pd.merge(df1, df2, left_index=True, right_index=True))

# Merge DataFrames Using Concat

print("Merge DataFrames Using Concat")

print(pd.concat([df1, df2], axis=1))

(.env) boris@boris-All-Series:~/VALUEPY$ python3 mergePandas.py

   rating  points

a      90      25

b      85      20

c      82      14

d      88      16

e      94      27

f      90      20

g      76      12

h      75      15

   assists  rebounds

a        5        11

c        7         8

d        7        10

g        8         6

m        5         6

n        7         9

Merge DataFrames Using Join

   rating  points  assists  rebounds

a      90      25      5.0      11.0

b      85      20      NaN       NaN

c      82      14      7.0       8.0

d      88      16      7.0      10.0

e      94      27      NaN       NaN

f      90      20      NaN       NaN

g      76      12      8.0       6.0

h      75      15      NaN       NaN

Merge DataFrames Using Merge

   rating  points  assists  rebounds

a      90      25        5        11

c      82      14        7         8

d      88      16        7        10

g      76      12        8         6

Merge DataFrames Using Concat

   rating  points  assists  rebounds

a    90.0    25.0      5.0      11.0

b    85.0    20.0      NaN       NaN

c    82.0    14.0      7.0       8.0

d    88.0    16.0      7.0      10.0

e    94.0    27.0      NaN       NaN

f    90.0    20.0      NaN       NaN

g    76.0    12.0      8.0       6.0

h    75.0    15.0      NaN       NaN

m     NaN     NaN      5.0       6.0

n     NaN     NaN      7.0       9.0

Calculate Principal Component Analysis (PCA) in Python

 В NumPy нет функции pca(), но мы можем легко рассчитать анализ основных компонентов шаг за шагом, используя функции NumPy.

В приведенном ниже примере определяется небольшая матрица 3 × 2, центрируются данные в матрице, вычисляется ковариационная матрица центрированных данных, а затем собственное разложение ковариационной матрицы. Собственные векторы и собственные значения берутся как главные компоненты и сингулярные значения и используются для проецирования исходных данных.

(.env) boris@boris-All-Series:~/MATRIXPCA$ cat matrixPCA2.py

from numpy import array

from numpy import mean

from numpy import cov

from numpy.linalg import eig

# Define a matrix

A = array([[4, 5], [6, 7], [8, 9]])

print("Defined a matrix = ","\n",A)

# calculate the mean of each column

M = mean(A.T, axis=1)

print("Calculate the mean of each column = ",M)

# center columns by subtracting column means

C = A - M

print("Center columns by subtracting column means = ","\n",C)

# calculate covariance matrix of centered matrix

V = cov(C.T)

print("Covariance matrix of centered matrix = ","\n",V)

# eigendecomposition of covariance matrix

values, vectors = eig(V)

print("Vectors = ","\n",vectors)

print("Values = ", values)

# project data

P = vectors.T.dot(C.T)

print("Project data = ","\n",P.T)

(.env) boris@boris-All-Series:~/MATRIXPCA$ python3 matrixPCA2.py

Defined a matrix =  

 [[4 5]

 [6 7]

 [8 9]]

Calculate the mean of each column =  [6. 7.]

Center columns by subtracting column means =  

 [[-2. -2.]

 [ 0.  0.]

 [ 2.  2.]]

Covariance matrix of centered matrix =  

 [[4. 4.]

 [4. 4.]]

Vectors =  

 [[ 0.70710678 -0.70710678]

 [ 0.70710678  0.70710678]]

Values =  [8. 0.]

Project data =  

 [[-2.82842712  0.        ]

 [ 0.          0.        ]

 [ 2.82842712  0.        ]]

Мы можем рассчитать анализ основных компонентов для набора данных, используя класс PCA() в библиотеке scikit-learn. Преимущество этого подхода заключается в том, что после расчета прогноза его можно довольно легко применять к новым данным снова и снова.

При создании класса в качестве параметра можно указать количество компонентов.Сначала класс подгоняется к набору данных, вызывая функцию fit(), а затем исходный набор данных или другие данные можно спроецировать в подпространство с выбранным числом измерений, вызывая функцию transform().После подгонки к собственным значениям и основным компонентам можно получить доступ в классе PCA через атрибуты Explain_variance_ и component_.

(.env) boris@boris-All-Series:~/MATRIXPCA$ cat reusablePCA.py

# Principal Component Analysis

from numpy import array

from sklearn.decomposition import PCA

# define a matrix

A = array([[4, 5], [6, 7], [8, 9]])

print(A)

# create the PCA instance

pca = PCA(2)

# fit on data

pca.fit(A)

# access values and vectors

print(pca.components_)

print(pca.explained_variance_)

# transform data

B = pca.transform(A)

print(B)

(.env) boris@boris-All-Series:~/MATRIXPCA$ python3 reusablePCA.py

[[4 5]

 [6 7]

 [8 9]]

[[ 0.70710678  0.70710678]

 [-0.70710678  0.70710678]]

[8. 0.]

[[-2.82842712e+00 -2.22044605e-16]

 [ 0.00000000e+00  0.00000000e+00]

 [ 2.82842712e+00  2.22044605e-16]]