неділя, 21 листопада 2021 р.

Створення фрейму із об'єднаних списків, задання імен рядків і стовпчиків

Нехай маємо 5 списків
L1=[1.     , 0.96   , 0.988  , 0.996  , 0.9952 , 0.996  , 0.99912]
L2=[ 0.92   , 0.944  , 0.98   , 0.97   , 0.9888 , 0.9912 , 0.99752]
L3=[0.64   , 0.872  , 0.912  , 0.918  , 0.96   , 0.9716 , 0.99064]
L4=[0.64   , 0.76   , 0.768  , 0.828  , 0.8832 , 0.9176 , 0.96324]
L5=[0.28   , 0.504  , 0.656  , 0.696  , 0.8032 , 0.822  , 0.90848]
Утворимо з них фрейм і задамо імена колонок і рядків
pdd=pd.DataFrame([L1,L2,L3,L4,L5],columns=['100','500','1000','2000','5000','10000','100000'])
pdd.rename({0: 'розмірність 2', 1: 'розмірність 3',2: 'розмірність 4',
3:'розмірність 10',4: 'розмірність 20'}, axis='index',inplace=True)

                 100	500	 1000  2000	5000	10000	100000
----------------------------------------------------------------------
розмірність 2 	1.00	0.960	0.988	0.996	0.9952	0.9960	0.99912
розмірність 3  	0.92	0.944	0.980	0.970	0.9888	0.9912	0.99752
розмірність 4	0.64	0.872	0.912	0.918	0.9600	0.9716	0.99064
розмірність 10	0.64	0.760	0.768	0.828	0.8832	0.9176	0.96324
розмірність 20	0.28	0.504	0.656	0.696	0.8032	0.8220	0.90848

субота, 20 листопада 2021 р.

Наївний класифікатор Баєса

В основі класифікації лежить гіпотеза максимальної ймовірності, тобто вважається, що об'єкт $x=(x_1,x_2,\ldots,x_n)$ належить класу $c^*$ з множини класів $C$ якщо на $c^*$ досягається найбільша апостеріорна (після випробовування) ймовірність $$c^*=\arg \max_{c \in C} P(c_i\mid x).$$ За формулою Баєса $$ P(c \mid x)=\frac{P(c) P(x|c)}{P(x)} $$ Оскільки $P(x)$ константа, то $$ \arg \max_{C} P(c\mid x)=\arg \max_{C} \frac{P(c_i) P(x|c)}{P(x)}=\arg \max_{C} P(c) P(x|c) $$ Далі робиться ''наївне'' припущення що для кожного класу ознаки об'єкту $x$ незалежні між собою, тобто $$ P(x_i | c, x_1, \dots, x_{i-1}, x_{i+1}, \dots, x_n) = P(x_i | с). $$ Звідси $$ P(x|c)= P(x_1,x_2,\ldots,x_n|c)=P(x_1|c) P(x_2|c) \cdots P(x_n|c)=\prod_{i=1}^n P(x_i|c). $$ Тоді $$c^*=\arg \max_{c \in C} P(c) \prod_{i=1}^n P(x_i|c).$$ На практиці, щоб уникнути роботи з малими числами, застосовують логарифмування \begin{gather*} c^*=\arg \max_{c \in C} \log\left( P(c) \prod_{i=1}^n P(x_i|c)\right)=\arg \max_{c \in C} \log P(c) +\sum_{i=1}^n \log P(x_i|c). \end{gather*} Це можна робити оскільки логарифм є монотонно зростаючою функцією і логарифмування не не змінить точку максимуму. Для завершення класифікації нам потрібно знати ймовірності класів $P(c)$ та ймовірності ознак $P(x_i|c).$ Оскільки у нас дискретні величини, то заміно ймовірності частотами. Тоді ймовірність $P(c)$ рівна частоті появи об'єктів з класу $c$ у вибірці, $$ P(c)=P(Y=c)=\frac{1}{|X|}\sum_{i=0}^{|X|}[y_i=c]. $$ Так само підрахунком шукаються $P(x_i|c)$ $$ P(x|c)=\frac{\displaystyle \sum_{i=0}^{|X|}[y_i=c \wedge X_i=x]} {P(c)}. $$

За іншим ( генеративним) підходом для знаходження невідомих ймовірностей $P(x_i|c)$ робиться припущення, що ознаки розподілені за деяким конкретним законом розподілу. Наприклад, в одномірному випадку коли розглядається лише одна ознака, якщо вибрати гаусівський закон розподілу , то $$ P(x|c)=\frac{1}{\sqrt{2\pi \sigma_c}}e^{-\frac{(x-\mu_c)^2}{2\sigma_{k}^2}}, $$ де параметри $\sigma_c, \mu_c$ оцінюються з вибірки.

пʼятниця, 29 жовтня 2021 р.

Приклад побудови дерева рішень в sklearn

Розглянемо побудову дерева для класифікації набору даних ірисів.
import numpy as np
from sklearn import datasets
iris = datasets.load_iris()
X = iris.data
y = iris.target
print('Атрибути даних:',data.target_names)
print('Форма даних:', X.shape)
Атрибути даних:
['setosa' 'versicolor' 'virginica']
Форма даних:
(150,4)
Розбиваємо данні на навчальну та тестову вибірки
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 67, test_size = 0.25)
Імпортуємо Decision tree класифікатор з бібліотеки sklearn, встановлюємо критерій переходу entropy. За умовчанням використовується критерій Джині.
from sklearn.tree import DecisionTreeClassifier
clf = DecisionTreeClassifier(criterion = 'entropy')
Навчаємо дерево на навчальному наборі
clf.fit(X_train, y_train)
DecisionTreeClassifier(ccp_alpha=0.0,class_weight=None,criterion='entropy',
max_depth=None, max_features=None, max_leaf_nodes=None,
min_impurity_decrease=0.0, min_impurity_split=None,
min_samples_leaf=1, min_samples_split=2,
min_weight_fraction_leaf=0.0, presort='deprecated',
random_state=None, splitter='best')
Виконуємо прогнозування міток на тестових даних
y_pred =  clf.predict(X_test)
Знаходимо оцінки точності класифікації
from sklearn.metrics import accuracy_score
print('Точність на тренувальних даних: ', accuracy_score(y_true=y_train, y_pred=clf.predict(X_train)))
print('Точність на тестових даних: ', accuracy_score(y_true=y_test, y_pred=y_pred))
#Output:
Точність на тренувальних даних:  1.0
Точність на тестових даних:  0.9473684210526315
Будуємо матрицю невідповідностей
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
cm = confusion_matrix(y_test, y_pred, labels=clf.classes_)
disp = ConfusionMatrixDisplay(confusion_matrix=cm,display_labels=clf.classes_)
disp.plot()
plt.show()
Як бачимо, на тестовому наборі допущено лише дві помилки.

Візуалізуємо дерево

from matplotlib.pyplot import figure
figure(figsize=(8,10))
from sklearn import tree
tree.plot_tree(clf)
plt.show()
В вузлах дерева знаходяться предикати, які керують процесом класифікації Визначаємо важливість ознак
print("Важливість ознак:  {}".format(clf.feature_importances_))
Важливість ознак:  [0.03417269 0.02454685 0.90530355 0.0359769 ]
Бачимо, що дві останні ознаки вносять найбільший вклад в класифікацію. Тому навчаємо нову модель відкинувши ознаки з меншим вкладом. РОбота з двома ознаками дозволяє візуалізувати області прийняття рішень
from mlxtend.plotting import plot_decision_regions # Потрібно встановити пакет mlxtend
X = iris.data[:, [2, 3]]
y = iris.target
X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.3)
clf = DecisionTreeClassifier(criterion='entropy')
clf.fit(X_train, y_train)
plot_decision_regions(X_train, y_train, clf)
plt.xlabel('petal length [cm]')
plt.ylabel('petal width [cm]')
plt.legend(loc='upper left')
plt.tight_layout()
plt.show()

субота, 16 жовтня 2021 р.

Дерева рішень

Дерево рішень(decision trees) це алгоритм машинного навчання для задач класифікації та регресії, який зображується у вигляді повного дерева, як правило бінарного. Кожен листок (термінальний вузол) дерева помічений міткою класу, в кожному вузлі знаходиться деякий предикат, аргументом якого є об'єкт призначений для класифікації. Процес класифікації відбувається шляхом руху об'єкта деревом від кореневого вузла до листка, мітка якого і присвоюється об'єкту, чим і завершується класифікація. Рух об'єкта регулюється предикатами, які в кожному нелистковому вузлі визначають на основі перевірки ознак об'єкта, в який саме із дочірніх вузлів він переміститься. Саме дерево, та форма предикатів в кожному його вузлі, конструюється у процесі навчання.

понеділок, 11 жовтня 2021 р.

Реалізація алгоритму $k$-найближчих сусідів.

Ілюстрація на прикладі датасет wine який вже є в sklearn.
from sklearn import datasets
#завантажуємо dataset
wine = datasets.load_wine()
 
Дані можна при потребі передати в pandas
wine_pd=pd.DataFrame(data= wine.data, columns=wine.feature_names) 
Ці дані є результатами хімічного аналізу вин, вирощених в одному регіоні в Італії, але отриманих з трьох різних сортів винограду. Аналіз визначив 13 хімічних складових, знайдених у кожному з трьох типів вин і які знаходяться в колонках набору.
 # назви ознак 
print(wine.feature_names)
['alcohol', 'malic_acid', 'ash', 'alcalinity_of_ash', 'magnesium', 'total_phenols', 'flavanoids', 'nonflavanoid_phenols', 'proanthocyanins', 'color_intensity', 'hue', 'od280/od315_of_diluted_wines', 'proline']
 
В колонці target знаходиться номер типу - 0, 1, або 2 , до якого відноситься вино з даним хімічним аналізом. Данні записані в масивах 'data', 'target'.
wine.target
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 2]) 
Розіб'ємо дані на навчальні і тестові.
#в scikit-learn
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(wine.data, wine.target, test_size=0.3) # 70\% тренувальна вибірка і  30\% тестова
# В  pandas вручну
f_target=df['y']
df_data=df.iloc[:,1:]
X_train, X_test, y_train, y_test = train_test_split(df_data, df_target, test_size=0.3) 
Навчаємо модель для кількості сусідів рівній 5 і виконуємо прогнозування на тестовому наборі. Щоб отримати прогнози для тестових даних, ми викликаємо метод predict. Для кожної точки тестового набору він знаходить її найближчих 5 сусідів в навчальному наборі і знаходить серед них клас який зустрічається найчастіше.
from sklearn.neighbors import KNeighborsClassifier
#Створюємо  KNN класифікатор
knn = KNeighborsClassifier(n_neighbors=5)
#Тренуєил модель на тренувальному  наборі
knn.fit(X_train, y_train)
#Виконуємо прогнозування на тестовому наборі
y_pred = knn.predict(X_test)
y_pred
[1 2 2 2 1 2 2 2 2 0 0 0 2 0 1 2 2 2 0 0 1 0 2 0 2 1 2 2 1 0 2 1 2 1 0 1 2
 1 2 1 0 0 2 1 0 1 2 0 1 2 1 2 1 0]
Для оцінки точності використаємо метрику metrics.accuracy_score, яка обчислює частку правильно класифікованих об'єктів з тестового набору $$ \frac{1}{n}\sum_{i=1}^n [y\_pred[i]=y\_test[i]]. $$ Якщо встановити параметр normalize=False, то метрика повертає загальну кількість елементів двох списків, які співпадають, наприклад
A = [0, 2, 1, 3]
B = [0, 1, 2, 3]
accuracy_score(A, B)
0.5
accuracy_score(A, B, normalize=False)
2
Оцінюємо точність моделі порівнюючи отримані результати з тестовим набором
from sklearn import metrics
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))
Accuracy: 0.6666666666666666
Точність може сильно відрізнятися оскільки залежить від конкретного розбиття даних. Знаходимо при якій кількості сусідів точність найкраща
 X_train , X_test , y_train , y_test = train_test_split(wine.data, wine.target,test_size=0.25)
training_accuracy = []
test_accuracy=[]
# задаємо діапазон n_neighbors від 1 до 30
neighbors_settings = range(1, 30)
for n_neighbors in neighbors_settings:
# будуємо модель
    knn = KNeighborsClassifier(n_neighbors=n_neighbors)
    knn.fit(X_train, y_train)
    y_pred = knn.predict(X_test)
# записуємо точність на навчальному наборі
    training_accuracy.append(metrics.accuracy_score(y_test, y_pred))
# записуємо точність на тестовому  наборі
    test_accuracy.append(metrics.accuracy_score(y_train, y_train_pr))
#Знаходимо найкращу точність
print('Найкраща точність при k=',np.argmax(training_accuracy))
Будуємо графік точності
from matplotlib.pyplot import figure
figure(figsize=(10,8))
plt.plot(neighbors_settings, training_accuracy, label="точність на тестовому наборі")
#plt.plot(neighbors_settings, test_accuracy, label="точність на тестовому наборі")
plt.ylabel("Точність")
plt.xlabel("кількість сусідів")
plt.legend()
Форма графіків, їхнє взаємне розташування та оптимальне значення $k$ залежать від конкрентного розбиття на навчальну та тестову вибірки і можуть сильно відрізнятися від наведеного тут.

понеділок, 27 вересня 2021 р.

Побудова гістограми

from matplotlib import pyplot
from pylab import rcParams
rcParams ["figure.figsize"] = 10, 8
data = pd.read_csv('USA_Housing.csv')
data.columns
Index(['Avg. Area Income', 'Avg. Area House Age', 'Avg. Area Number of Rooms',
       'Avg. Area Number of Bedrooms', 'Area Population', 'Price', 'Address'],
      dtype='object')
Для однієї колонки
data['Avg. Area Income'].hist()
pyplot.show()
Для двох колонок
data[['Avg. Area Income', 'Avg. Area House Age']].hist()
pyplot.show()
Для всіх числових колонок датафрейму
data.hist()
pyplot.show()

неділя, 26 вересня 2021 р.

Модель

Моделлю (predictive model) називається параметричне сімейство відображень $$ A = \{g(x, \theta) \mid \theta \in \Theta \}, $$ де $g: X \times \Theta \to Y$ -- деяка фіксована функція, $\Theta$ - множина допустимих значень параметра $\theta$, яка називається простором параметрів, або простором пошуку(search space).

Тут $\theta$ -- шуканий вектор параметрів нашої моделі.

Процес знаходження оптимального параметра моделі $\theta$ по навчальній вибірці $X^{l}$ називають налаштуванням (fitting) або навчанням (training, learning) алгоритму $a \in A.$

Метод навчання це відображення $\mu: (X \times Y)^l \to A$ яке довільній вибірці $X^l= (x_i,y_i)_{i=1}^l$ ставить у відповідність деякий алгоритм $a \in A.$

Задача машинного навчання розбивається на два етапи -- на першому етапі ( етап навчання) відбувається навчання моделі, в результаті якого будується алгоритм $a=\mu(X^l)$. На другому етапі ( етап застосування), алгоритм на нових об'єктах $y$ видає відповіді $y=a(x).$

Формальна постановка задачі машинного навчання

Нехай задана множина об'єктів $X$, множина допустимих відповідей $Y$, і існує цільова функція (target function) $y^*: X \to Y,$ значення якої $y_i = y^*(x_i)$ відомі тільки на скінченній підмножині із $l$ об'єктів $\{x_1, \ldots, x_l \} \subset X$. Пари об'єкт-відповідь $(x_i, y_i)$ називаються прецедентами. Множина із $l$ пар $X^l = \{(x_i, y_i)\}_{i=0}^{l}$ називається навчальною вибіркою (training sample).

Задача машинного навчання (навчання за прецедентами) полягає в тому, щоб за вибіркою $X^l$ відновити залежність $y^*$, тобто побудувати вирішальну функцію (decision function) $a: X \to Y$, яка наближала (апроксимувала) б цільову функцію $y^*(x)$, причому не тільки на об'єктах навчальної вибірки, а й на всій множині $X.$ Вирішальна функція $a$ повинна допускати ефективну комп'ютерну реалізацію; з цієї причини будемо називати її алгоритмом.

З точки зору математики, ситуація виглядає так -- нехай є деяка невідома функція $f:X \to Y$, і нам дано лише обмеження $\bar f: \bar X \to Y$ цієї функції на підмножину $\bar X \subset X.$ В задачі машинного навчання потрібно відновити функцію $f$ по її обмеженню $\bar f$. В такій загальній постановці не існує єдиного розв'язку, тому для обмеження можливих варіантів будемо виходити з припущення, що $f$ визначає деякий закон природи і множина $\bar X$ достатньо велика щоб цей закон відновити.

Машинне навчання, по суті, займається розглядом наступних питань:

  • Яким чином задаються об'єкти?
  • Якими можуть бути відповіді?
  • Як будувати функцію яка апроксимує нашу невідому залежність $a$?
  • В якому сенсі $a$ наближає $y$?

понеділок, 20 вересня 2021 р.

Машинне навчання це наука, яка розробляє і вивчає технології розробки алгоритмів, що навчаються на великій кількості готових розв'язків задач, подібних до поставленої задачі. В процесі навчання вони отримують досвід і їхня ефективність збільшується.

понеділок, 23 серпня 2021 р.

Статистичні дані числових стовпців

Знаходження екстремальних значень, суми, середнього і медіанного значення та підрахунку кількості значень
dataframe = pd.read_csv('titanic.csv')
print('Максимум:', dataframe['Age'].max())
print('Мінімум:', dataframe['Age'].min())
print('Середнє арифметичне:', dataframe['Age'].mean())
print('Медіана:', dataframe['Age'].median())
print('Мода:', dataframe['Age'].mode())
print('Сума елементів колонки:', dataframe['Age'].sum())
print('Кількість:', dataframe['Age'].count())
Максимум: 80.0
Мінімум: 0.42
Середнє арифметичне: 29.69911764705882
Медіана: 28.0
Мода: 0    24.0
dtype: float64
Сума елементів колонки: 21205.17
Кількість: 714
#До всього фрейму
PassengerId    891
Survived       891
Pclass         891
Name           891
Sex            891
Age            714
SibSp          891
Parch          891
Ticket         891
Fare           891
Cabin          204
Embarked       889
dtype: int64

четвер, 19 серпня 2021 р.

Додавання нових колонок і стовпчиків

Створення порожнього фрейму і додавання нових колонок
dataframe = pd.DataFrame()
# Створити і додати колонки
dataframe['Name'] = ['Іван Іваненко ', 'Петро Петренко']
dataframe['Age'] = [38, 25]
dataframe['Driver'] = [True, False]
# Показати фрейм
dataframe
     Name	        Age	Driver
0	Іван Іваненко	38	True
1	Петро Петренко	25	False
Створення і додавання нового рядка до фрейму
 # Створення рядка
new_person = pd.Series(['Сидір  Сидоренко', 40, True], index=['Name','Age','Driver'])
# Додавання в кінець фрейму
dataframe.loc[len(dataframe)]=new_person

            Name	Age	Driver
0	Іван Іваненко	38	True
1	Петро Петренко	25	False
2	Сидір Сидоренко	40	True

вівторок, 17 серпня 2021 р.

Завантаження Exel-файлу

# Завантаження бібліотеки
import pandas as pd
#різні режими завантаження
dataframe = pd.read_excel('file.xlsx',, index_col=None, header=None) 
dataframe = pd.read_excel('file.xlsx', sheetname=0, header=1)
#  або за URL
url = 'https://site/file.xls'
dataframe = pd.read_excel(url, sheetname=0, header=1)

понеділок, 9 серпня 2021 р.

Перегляд фрейму

Створимо синтетичний набір даних індексований часовим рядом DatetimeIndex:
dates = pd.date_range("20210109", periods=6)
data = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list("ABCD"))
data.shape
(6,4)

data

                A	         B	         C	        D
 ___________________________________________________________________________
2021-01-09	0.388125	-1.202547	-1.249485	0.751333
2021-01-10	1.033439	0.175955	0.100732	-0.062862
2021-01-11	0.786448	-0.762654	0.542246	0.395827
2021-01-12	0.523685	0.176968	-0.606602	-1.421410
2021-01-13	0.609091	0.446525	-0.237162	-0.075100
2021-01-14	0.774839	0.149868	0.494714	0.054106

Перегляд перших трьох і останніх двох рядків фрейму


data.head(3)

                 A            B            C         D 
_________________________________________________________________________
2021-01-09 & -0.384154 & -1.015396 & -2.790040 &  0.021946 
2021-01-10 &  0.497643 &  1.156721 & -0.578700 &  0.453576
2021-01-11 & -0.128772 & -0.845799 &  0.954693 & -1.095001 
data.tail(2)
               A             B        C          D  
_________________________________________________________________
2021-01-13   -0.364495   -0.887037    0.085531    0.427110  
2021-01-14    0.799109    0.790806   -0.302740   1.338427  
Перегляд останньої колонки фрейму використовуючи зрізи
data.iloc[:,-1:]
	             D
 _______________________
2021-01-09	0.751333
2021-01-10	-0.062862
2021-01-11	0.395827
2021-01-12	-1.421410
2021-01-13	-0.075100
2021-01-14	0.054106

# тільки значення без заголовків
data.iloc[:,-1:].values

array([[ 0.75133295],
       [-0.06286193],
       [ 0.39582721],
       [-1.42140991],
       [-0.07510039],
       [ 0.05410612]])
Перегляд всіх колонок крім останньої
data.iloc[:,:-1]
# тільки значення без заголовків
data.iloc[:,:-1].values
Вивід кількох сусідніх рядків отримується стандартним зрізом індексів. Функція data.take(список індексів) повертає рядки із вказаними номерами.
data[2:4]#  перегляд діапазону рядків
  
               A	         B	         C	        D
 __________________________________________________________________________
2021-01-11	0.786448	-0.762654	0.542246	0.395827
2021-01-12	0.523685	0.176968	-0.606602	-1.421410
# пепрегляд рядків за списком номерів
data.take([2,4])

               A            B	          C	       D
  ____________________________________________________________________________
2021-01-11	0.786448	-0.762654	0.542246	0.395827
2021-01-13	0.609091	0.446525	-0.237162	-0.075100
 
Вивід лише значень
data.take([2,4]).values
  
  array([[ 0.78644793, -0.76265406,  0.542246  ,  0.39582721],
       [ 0.60909124,  0.44652491, -0.23716184, -0.07510039]])
   

неділя, 8 серпня 2021 р.

Розподіл даних на тестову та навчальну вибірки

Розподіл даних на на навчальний та тестовий набори є важливим кроком попередньої обробки даних який покращує ефективність та точність моделі.
  • Тренувальний набір (X_train): Підмножина набору даних відгуки яких (y_train) відомі і які використовуються для навчання моделі.
  • Тестовий набір ( X_test): підмножина набору даних для перевірки навченої моделі, відгуки яких (y_train) відомі і які використовуються для перевірки якості навченої моделі на тренувальних даних
Для розподілу використовується клас train_test_split sklearn-бібліотеки model_selection. Приклад розбиття
X, y = np.arange(16).reshape((-1, 2)),range(8)
X
array([[ 0,  1],
       [ 2,  3],
       [ 4,  5],
       [ 6,  7],
       [ 8,  9],
       [10, 11],
       [12, 13],
       [14, 15]])
list(y)
[0, 1, 2, 3, 4, 5, 6, 7]
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(X, y,test_size = 0.2,random_state = 0)
[X_train, y_train]	
[array([[14, 15],
        [ 4,  5],
        [ 8,  9],
        [ 6,  7],
        [12, 13]]), [7, 2, 4, 3, 6]]
																														
[X_test, y_test]
[array([[ 2,  3],
        [10, 11],
        [ 0,  1]]), [1, 5, 0]]
В train_test_split() ми передали 4 параметри -- два масиви X, y наборами даних і відгуками, test_size -- частка даних яка виділяється на тестовий набір, у нашому випадку це 33%, за умовчанням цей параметр рівний $0.25.$ Останній параметр random_state є параметром для генератора випадкових випадків, який перемішує дані.

субота, 7 серпня 2021 р.

Збереження фрейму в CSV-файлі

Mathedemo
DataFrames-це двовимірна структура даних з індексами для рядків і стовпців, яка використовується для зберігання значення будь-якого типу. В основному, DataFrames є словником на основі масивів NumPy.
# створюємо тестову таблицю
dates = pd.date_range("20210109", periods=6)
data = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list("ABCD"))
#Зберігаємо у файлі
data.to_csv('file1.csv')

Зберігаємо без заголовків стовпчиків і індексів рядків

data.to_csv('file2.csv', header=False, index=False)

Завантаження CSV-файлу у фрейм

from pandas import read_csv
filename = 'melb_data.csv'
melbourne_data = pd.read_csv(filename)
# розмір таблиці 
print(melbourne_data.shape)
(18396, 22)
# інформація про назви колонок ( ознак)
melbourne_data.columns
Index(['Unnamed: 0','Suburb','Address', 'Rooms', 'Type', 'Price', 'Method',
       'SellerG', 'Date', 'Distance', 'Postcode', 'Bedroom2', 'Bathroom',
       'Car', 'Landsize', 'BuildingArea', 'YearBuilt', 'CouncilArea',
       'Lattitude', 'Longtitude', 'Regionname', 'Propertycount'],
      dtype='object')