Сохранение лучшей модели

#python #нейронные_сети #машинное_обучение #keras

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

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

Ответы

Ответ 1

Вы можете воспользоваться callbacks для сохранения лучшей модели и для ранней остановки
(чтобы избежать бесполезных вычислений и ускорить время обучения модели):

from keras.callbacks import EarlyStopping, ModelCheckpoint

early_stop = EarlyStopping(monitor='val_acc', min_delta=0.0001,
                           patience=5, verbose=1, mode='auto')
chkpt = ModelCheckpoint(model_filename, 
                        monitor='val_loss', 
                        verbose=1, 
                        save_best_only=True, 
                        mode='auto')
callbacks = [early_stop, chkpt]

hist = model.fit(x_train, y_train, 
                 batch_size=Batch_size, epochs=Epochs, 
                 validation_data=(x_val, y_val), 
                 callbacks=callbacks)

Не получается натренировать нейронную сеть

#python #машинное_обучение #numpy

Народ, всем привет! Столкнулся с бедой - нужно натренировать сеть по приложенному
датасету (выше) и образцу с хабра (сам пост). Итоговый результат никак не похож на
изначальный набор значений. С чем я мог налажать: грешу на сигмоиду, но упустить что-то
важное из внимания мог и в любом другом месте. Огромное спасибо, если откликнитесь!

Описание сета

Данные

(Предварительно удалил строчки с вопросительными знаками и поместил сет в txt).

По-английски/in English

import numpy as np

# sigmoid func
def sigmoid(x, deriv=False):
    if deriv:
        # print(sigmoid(x) * (1 - sigmoid(x)))
        return sigmoid(x) * (1 - sigmoid(x))
    return 1 / (1 + np.exp(-x))


# input initialization
dataset = np.genfromtxt('dataset.txt', delimiter=',')
X = dataset[..., 0:12]
y = np.array([dataset[..., 13]]).T

# input normalization
Xn = X / X.max(axis=0)
yn = y / y.max(axis=0)

# random numbers initialization
np.random.seed(1)
syn0 = 2 * np.random.random((12, 1)) - 1

for i in range(50000):
    # direct error propagation
    l0 = Xn
    l1 = sigmoid(np.dot(l0, syn0))
    # error computing
    l1_error = yn - l1
    # multiply this by the slope of sigmoid
    # using values of l1
    l1_delta = l1_error * sigmoid(l1, True) # - !
    # weights update
    syn0 += np.dot(l0.T, l1_delta)  # - !
print("Output data after training: ")
print(l1)

Actual result        Required result:      
[[8.25305827e-28]    ~0
 [9.99999908e-01]    ~0.5
 [5.25318843e-04]    ~0.25
 [2.41309677e-22]    ~0
 [2.09811612e-28]    ~0
 [2.37186828e-34]    ~0
 [1.43044972e-07]    ~0.75
 [6.83698176e-30]    ~0
...                  ...

    

Ответы

Ответ 1

Дело в том, что это датасет для мультиклассовой классификации: y принимает значения
1, 2, 3, 4, 5. Для решения такой задачи нужна другая функция активации (softmax обычно)
и другая функция потерь (обычно crossentropy). Советую взять датасет с бинарным таргетом.

Случайный лес и бэггинг деревьев решений

#python #pandas #машинное_обучение #dataframe #numpy

Запрограммировала случайный лес и бэггинг деревьев решений. 

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

Как правильно должна выглядеть программа? Надо ли отдельно реализовать бэггинг и
деревья решений?

Код:

 import numpy as np
 import pandas as pd
 from sklearn.model_selection import cross_val_score
 from sklearn.cross_validation import train_test_split
 from sklearn.ensemble.forest import RandomForestClassifier
 from sklearn.ensemble import BaggingClassifier
 from sklearn.tree import DecisionTreeClassifier
data = pd.read_csv('C:\\Users\\Vika\\Downloads\\1500.csv', ";",decimal =',', skipinitialspace=True)
 data.head()
 kfold = 10
 itog_val1 = {} 
 itog_val2 = {} 
 itog_val3 = {} 
 itog_val4 = {} 
 itog_val5 = {} 
 itog_val6 = {}
 X = data.drop('Y1', axis=1).values[:, :8] 
 y = data['Y1'].values
 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
 print ('обучающая выборка X:\n', X_train[:6])
 print ('\n')
 print ('y_train У:\n', y_train[:10])
 print (' \n')
 print ('тестовая выборка Х:\n', X_test[:6])
 print ('\n')
 print ('y_test У\n', y_test[:10])
 first_tree = RandomForestClassifier(n_estimators=100)  
 scores = cross_val_score(first_tree, X_train, y_train, cv=kfold) 
 itog_val1 = scores 
 print(itog_val1)  
 first_tree1 = DecisionTreeClassifier(max_depth=1)    
 scores = cross_val_score(first_tree, X_train, y_train, cv=kfold)
 itog_val4 = scores 
 print(itog_val4)
 first_tree.fit(X_train, y_train) 
 first_tree.score(X_test, y_test)
 y_test_predicted = first_tree.predict(X_test) 
 print ('RandomForestClassifier X\n', X_test[:9])
 print ('\n')
 print ('RandomForestClassifier y\n', y_test[:11]) 
 first_tree1.fit(X_train, y_train)
 first_tree1.score(X_test, y_test)
 y_test_predicted = first_tree1.predict(X_test)
 print ('DecisionTreeClassifier X\n', X_test[:9])
 print ('\n')
 print (' DecisionTreeClassifier y\n', y_test[:11])
 first_bagging.fit(X_train, y_train)
 first_bagging.score(X_test, y_test)
 y_test_predicted = first_bagging.predict(X_test)
 print ('BaggingClassifier X\n', X_test[:9])
 print ('\n')
 print (' BaggingClassifier y\n', y_test[:11])
 res = pd.DataFrame(np.column_stack((y_test, y_test_predicted, X_test)), 
               columns=['Y1','YR'] + data.columns[1:9].tolist())
 (res['Y1']!= res['YR']).mean()
 res1 = pd.DataFrame(np.column_stack((y_test, y_test_predicted, X_test)), 
               columns=['Y1','YD'] + data.columns[1:9].tolist())
 (res1['Y1']!= res1['YD']).mean() 
 res2 = pd.DataFrame(np.column_stack((y_test, y_test_predicted, X_test)), 
               columns=['Y1','YB'] + data.columns[1:9].tolist())
 (res2['Y1']!= res2['YB']).mean() 

    

Ответы

Ответ 1

Вы создали три DataFrame из одних и тех же данных:

res = pd.DataFrame(np.column_stack((y_test, y_test_predicted, X_test)), 
                   columns=['Y1','YR'] + data.columns[1:9].tolist())
...
res1 = pd.DataFrame(np.column_stack((y_test, y_test_predicted, X_test)), 
                    columns=['Y1','YD'] + data.columns[1:9].tolist())
...
res2 = pd.DataFrame(np.column_stack((y_test, y_test_predicted, X_test)), 
                    columns=['Y1','YB'] + data.columns[1:9].tolist())


как следствие процент несовпадений - одинаковый

Какие могут быть пути улучшения обобщающей способности ИНС на базе Keras?

#python #нейронные_сети #машинное_обучение #keras

Несколько дней назад я создавал тему с похожим вопросом: Проблема с обучением сети
в Keras: нет обобщающей способности сети, и там получил резонное замечание и совет.
Решив попробовать поработать с данными, в которых информация не утрачена (нежели в
прошлом топике), я собрал подобную ИНС, предварительно нормализовав данные (использование
StandardScaler оказалось лучше MinMax).

Дано:
База из 71 осциллограммы с 3002 отсчетами. Диапазон данных: от 0 до 10Е6. Данные
векторы разбиты на обучающую выборку и тестовую (36 и 35).  

Задача:
входным векторам присваивать значения на выходе в виде определенного числа (от 30
до 100). 

Ограничения:
нет возможности получить огромный датасет (из тысяч векторов) и возможный максимум
- сотня-полторы векторов.

Текущая конфигурация сети довольно неплохо обучается (в сравнении с предыдущей),
однако проблема с обобщением результатов все также существует. Хоть результат и лучше
он все еще не устраивает меня. Меняя конфигурации многослойного персептрона (число
нейронов в слое, число слоев) мне не удавалось сильно изменять выходной результат (разве
что, кроме времени обучения, что логично). Возможно я не подобрался к самой оптимальной
структуре ИНС, но пока есть только это. Кстати да, функцию обучения выбирал методом
научного тыка. Перепробовал разные методы и данный показал себя лучше всего.

Итак, отсюда у меня вопросы:
Какие возможные пути изменения ИНС для улучшения результата? К сожалению я все еще
новичок в этой области и знаком только с персептронами. Быть может вы сможете посоветовать
какие-то другие типы сетей? Если после нормализации у меня диапазон значений вектора
от -2 до 6, то как это влияет? На сколько мне известно, то на вход сети следует подавать
данные в диапазоне [0 1] или [-1 1].

Код сети:

#загружаем файл с образами
TRAIN_FILE="TRAIN30_100km.csv"
TEST_FILE="TEST30_100km.csv"

# размер вектора
img_rows, img_cols = 1, 3002

# Загружаем данные для обучения
train_dataset = np.loadtxt(TRAIN_FILE, skiprows=0, dtype='int', 
delimiter=",")
test_dataset = np.loadtxt(TEST_FILE, skiprows=0, dtype='int', delimiter=",")

# Выделяем данные для обучения
X_train = train_dataset[:, 1:]
X_test = test_dataset[:, 1:]

# нормализуем данные
scaler = StandardScaler()
x_train=scaler.fit_transform(X_train)
x_test=scaler.fit_transform(X_test)

# Выделяем правильные ответы
y_train = train_dataset[:,0]
y_test = test_dataset[:,0] 

# рисуем график нормализованного вектора и оригинального
y10 = x_train[6, :]
y11=X_train[6, :]
plt.figure(figsize=(8, 8))
plt.plot(y10)
plt.show()
plt.figure(figsize=(8, 8))
plt.plot(y11)
plt.show()

# Выделяем правильные ответы
y_train = train_dataset[:,0]
y_test = test_dataset[:,0]

model = Sequential()

model.add(Dense(10, input_dim=3002, 
activation="relu",kernel_regularizer=regularizers.l2(0.01)))
model.add(Dense(15, activation='relu', 
kernel_regularizer=regularizers.l2(0.01)))
model.add(Dense(5, activation='relu', 
kernel_regularizer=regularizers.l2(0.01)))
model.add(Dense(5, activation='relu'))
model.add(Dense(1))
model.compile( optimizer='Adagrad', loss="mse", metrics=['mae'])

print(model.summary())
model.fit(x_train, y_train, epochs=30, batch_size=1, 
verbose=2,validation_data=(x_test, y_test))



  Epoch 30/30
   - 0s - loss: 0.9548 - mean_absolute_error: 0.1053 - val_loss: 102.0822 - val_mean_absolute_error:
7.7214


mse, mae = model.evaluate(x_test, y_test, verbose=0)
predictions=model.predict(x_test)
print(predictions)
# ответы (правильные 31 33 35 37)
[20.31354 ]
[18.931906]
[21.085878]
[20.537167]


Ссылка на датасет.
    

Ответы

Ответ 1

Немного подумав, решил упростить НС по-максимуму и получил лучшие показатели.

Архитектура:

model = Sequential()
model.add(Dense(128, input_dim=3002, activation="relu", kernel_regularizer=l2(0.01)))
model.add(BatchNormalization())
model.add(Dense(1))
model.compile( optimizer='Adagrad', loss="mse", metrics=['mae', 'mse'])
hist = model.fit(x_train, y_train, epochs=300, batch_size=3, 
                 verbose=2,validation_data=(x_test, y_test),
                 callbacks=callbacks)


вывод:

Epoch 00147: val_mean_squared_error did not improve from 13.76798
Epoch 148/300
 - 0s - loss: 183.8615 - mean_absolute_error: 10.9775 - mean_squared_error: 180.3115
- val_loss: 23.7155 - val_mean_absolute_error: 3.2763 - val_mean
_squared_error: 20.1659

Epoch 00148: val_mean_squared_error did not improve from 13.76798
Epoch 00148: early stopping


оценка:

In [206]: model = load_model(model_fn)

In [207]: model.evaluate(x_test, y_test, verbose=1)
18/18 [==============================] - 2s 135ms/step
Out[207]: [17.30735206604004, 3.1715924739837646, 13.767986297607422]


сравнение тестового набора с предсказанными значениями:

In [208]: from sklearn.metrics import mean_absolute_error, mean_squared_error

In [209]: df = pd.DataFrame({'y_test':y_test.ravel(), 'y_pred':model.predict(x_test).ravel()})

In [210]: mean_squared_error(df['y_test'], df['y_pred'])
Out[210]: 13.76798614917061

In [211]: mean_absolute_error(df['y_test'], df['y_pred'])
Out[211]: 3.171592500474718

In [212]: df['abs_err'] = np.abs(df['y_test'] - df['y_pred'])

In [213]: df
Out[213]:
    y_test     y_pred   abs_err
0     39.0  41.414223  2.414223
1     41.0  38.207268  2.792732
2     43.0  49.000561  6.000561
3     73.0  73.476303  0.476303
4     33.0  32.048149  0.951851
5     78.0  76.682877  1.317123
6     53.0  57.643074  4.643074
7     54.0  58.276382  4.276382
8     67.0  63.092651  3.907349
9     49.0  53.009842  4.009842
10    89.0  87.252930  1.747070
11    65.0  62.399197  2.600803
12    63.0  68.281502  5.281502
13    58.0  55.078934  2.921066
14    48.0  43.649544  4.350456
15    80.0  72.487808  7.512192
16    60.0  60.331455  0.331455
17    47.0  45.445320  1.554680

In [217]: df[['y_test','y_pred']].plot()
Out[217]: 


Ответ 2

Немного поигрался с вашими данными - лучшее что у меня получилось:

mae: 3.8784
mse: 22.78249


вот весь код:

import pandas as pd
import numpy as np
from pathlib import Path
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from keras import Sequential
from keras.layers import *
from keras.regularizers import l2, l1
from keras.callbacks import EarlyStopping, ModelCheckpoint
from keras.models import save_model, load_model

def get_data(path, test_size=0.25):
    data = pd.concat([pd.read_csv(f, header=None) for f in Path(path).glob('*.csv')],
                     ignore_index=True).values
    scaler = StandardScaler()
    x, y = scaler.fit_transform(data[:, 1:]), data[:, [0]]
    return train_test_split(x, y, test_size=test_size)

path = r'/path/to/directory_with_data'
x_train, x_test, y_train, y_test = \
    get_data(path, test_size=0.25)

model_fn = str(Path(path) / 'model.h5')
early_stop = EarlyStopping(monitor='val_mean_squared_error', min_delta=0.0001,
                           patience=60, verbose=1, mode='auto')
chkpt = ModelCheckpoint(model_fn, 
                        monitor='val_mean_squared_error', 
                        verbose=1, 
                        save_best_only=True, 
                        mode='auto')
callbacks = [early_stop, chkpt]

model = Sequential()
model.add(Dense(45, input_dim=3002, activation="relu", kernel_regularizer=l2(0.01)))
model.add(BatchNormalization())
model.add(Dropout(0.04))
model.add(Dense(20, activation='relu', kernel_regularizer=l2(0.01)))
model.add(Dropout(0.01))
model.add(Dense(6, activation='relu', kernel_regularizer=l2(0.01)))
model.add(Dense(5, activation='relu'))
model.add(Dense(1))
model.compile( optimizer='adam', loss="mse", metrics=['mae', 'mse'])
hist = model.fit(x_train, y_train, epochs=300, batch_size=3, 
                 verbose=2,validation_data=(x_test, y_test),
                 callbacks=callbacks)


Сохраненная модель ...

Ошибка: TypeError: fit() missing 1 required positional argument: 'y'

#python #pandas #машинное_обучение #numpy #scikit_learn

Я пытаюсь сделать алгоритм на python, определяющий написанные от руки английские
буквы, но при попытке обучения появляется ошибка.
Мой код:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.neighbors import KNeighborsClassifier as knc

abc_train = pd.read_csv("alphabet.csv")

columns = ["let"]
for i in range(784):
    columns.append(f"px_{i+1}")
abc_train.columns = columns
label_name = abc_train["let"].values
let_train = abc_train.values[:, 1:]
pict_train = let_train.reshape(372450 , 28, 28)
knc = knc.fit( pict_train, label_name)


Ошибка:

TypeError                                 Traceback (most recent call last)
 in 
----> 1 knc = knc.fit( pict_train[1:14325], label_name)

TypeError: fit() missing 1 required positional argument: 'y'


Что я делаю не так? Как я могу решить эту проблему / ошибку ?
Может ли это быть из-за того, что в датасете не указан верный вывод?
    

Ответы

Ответ 1

Ошибка в том, что вы не создали объект класса KNeighborsClassifier, а использовали
метод класса KNeighborsClassifier.fit().

Попробуйте так:

from sklearn.neighbors import KNeighborsClassifier

knc = KNeighborsClassifier(n_neighbors=5)

...

knc.fit(pict_train, label_name)


PS @gil9red отлично дополнил ответ в комментарии:


  в питоне у методов объекта есть первый, неочевидный параметр self, в
  который кладется ссылка на объект, что метод вызвал и в случае вызова
  метода классом (а не объектом), в тот параметр self попал объект
  pict_train, а label_name, соответственно, попал в X, поэтому и
  ругается на y?

Подскажите как мне проверить модель ML c реальными данными

#python #python_3x #машинное_обучение #scikit_learn

from  sklearn import  datasets
iris=datasets.load_iris()

x=iris.data
y=iris.target

from sklearn.model_selection import train_test_split
x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=.5)

from sklearn import neighbors
classifier=neighbors.KNeighborsClassifier()

classifier.fit(x_train,y_train)

predictions=classifier.predict(x_test)

from sklearn.metrics import accuracy_score
print(accuracy_score(y_test,predictions))

# 0.9333333333333333


Каким образом мне можно проверить модель, задав ему X - ы, что бы он выдал мне предикт
по цветку:)
    

Ответы

Ответ 1

Вы уже проверили модель в данной строке: 

predictions=classifier.predict(x_test)


и получили массив предсказанных цветков:

In [308]: predictions
Out[308]:
array([1, 1, 1, 0, 2, 0, 0, 0, 0, 1, 0, 1, 2, 1, 1, 1, 2, 0, 2, 1, 1, 2, 1, 1, 1,
1, 0, 0, 2, 1, 0, 2, 2, 0, 2, 2, 2, 2, 1, 2, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1,
1, 2, 1, 2, 0, 0, 1, 2, 2, 0, 0,
       0, 2, 0, 0, 2, 0, 0, 0, 2, 2, 0])


чтобы получить соответствующие имена цветков: 

In [305]: X_test_names = np.take(iris.target_names, predictions)

In [306]: X_test_names
Out[306]:
array(['versicolor', 'versicolor', 'versicolor', 'setosa', 'virginica', 'setosa',
'setosa', 'setosa', 'setosa', 'versicolor', 'setosa', 'versicolor', 'virginica', 'versicolor',
'versicolor',
       'versicolor', 'virginica', 'setosa', 'virginica', 'versicolor', 'versicolor',
'virginica', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'setosa', 'setosa',
'virginica',
       'versicolor', 'setosa', 'virginica', 'virginica', 'setosa', 'virginica', 'virginica',
'virginica', 'virginica', 'versicolor', 'virginica', 'setosa', 'setosa', 'setosa',
'versicolor',
       'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor', 'versicolor',
'virginica', 'virginica', 'versicolor', 'versicolor', 'virginica', 'versicolor', 'virginica',
'setosa',
       'setosa', 'versicolor', 'virginica', 'virginica', 'setosa', 'setosa', 'setosa',
'virginica', 'setosa', 'setosa', 'virginica', 'setosa', 'setosa', 'setosa', 'virginica',
'virginica', 'setosa'],
      dtype='

ValueError: Error when checking input: expected input_120 to have 3 dimensions, but got array with shape (96, 7)

#python #python_3x #нейронные_сети #машинное_обучение #keras

У меня есть такой код:

a=[[1,23,345,235,235,644,757],
[2,455,325,235578,23524,6413,757567],
[3,123,125,2375,23554,64123,75778],
[...],
[35,244,245,231235,2158935,6567944,7567557]]

b=[[1],[-1],[0],[...],[1]]

c=np.array(a)
d=np.array(b)
print(c.shape)
print(d.shape)

inputs = Input(shape=(96,7))
x = Dense(64, activation='relu')(inputs)
x = Dense(64, activation='relu')(x)
predictions = Dense(10, activation='softmax')(x)
model = Model(inputs=inputs, outputs=predictions)
model.compile(optimizer='rmsprop',
              loss='categorical_crossentropy',
              metrics=['accuracy'])
model.fit(c, d)


Выводит:

(96, 7)
(96, 1)
ValueError: Error when checking input: expected input_120 to have 3 dimensions, but
got array with shape (96, 7)


Никак не могу понять в чем же тут проблема. Помогите пожалуйста.
    

Ответы

Ответ 1

у вас тут похоже две проблемы:


число строк (образцов) в размерности модели не учитывается. Т.е. вместо inputs =
Input(shape=(96,7)) используйте: inputs = Input(shape=(7,))
На последнем слое вы использовали 10 выходных нейронов (иными словами вы хотите посчитать
вероятности принадлежности к 10-ти классам), а на вход (в качестве y/target) вы подаете
тензор/матрицу с одним столбцом (модель же ожидает 10 столбцов). 


Для того чтобы исправить 2-ю проблему можно категоризировать (One-Hot-Encoding) d,
получив в итоге "One Hot Encoded" матрицу с 10-ю столбцами.

Пример:

In [46]: from keras.utils import to_categorical

In [47]: Y = to_categorical(d, num_classes=10)

In [48]: Y
Out[48]:
array([[0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
       [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.]], dtype=float32)




Весь исправленный код:

from keras import Model, Sequential
from keras.layers import *
from keras.utils import to_categorical

a=[[1,23,345,235,235,644,757],
[2,455,325,235578,23524,6413,757567],
[3,123,125,2375,23554,64123,75778],
[35,244,245,231235,2158935,6567944,7567557]]

b=[[1],[-1],[0],[1]]

X = np.array(a)
Y = to_categorical(np.array(b), num_classes=10)

model = Sequential()
model.add(Dense(64, activation='relu', input_dim=7))
model.add(Dense(64, activation='relu'))
model.add(Dense(10, activation='softmax'))

model.compile(optimizer='rmsprop',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

print(model.summary())

model.fit(X, Y)

Требуется помощь в выборе языка программирования [закрыт]

#java #машинное_обучение

        
             
                
                    
                        
                            Закрыт. На этот вопрос невозможно дать объективный ответ.
Ответы на него в данный момент не принимаются.
                            
                        
                    
                
                            
                                
                
                        
                            
                        
                    
                        
                            Хотите улучшить этот вопрос? Переформулируйте вопрос,
чтобы на него можно было дать ответ, основанный на фактах и цитатах, отредактировав его.
                        
                        Закрыт 2 года назад.
                                                                                
           
                
        
Допустим мне нужно написать компьютерную программу с сложным алгоритмом, который
будет работать с огромным объемом информации и еще туда придется впихнуть машинное
обучение. Чтобы вам было легче понять о чем я говорю, приведу в пример уже существующую
программу: Наса или кто другой написали программу для нахождения планет потенциально
пригодных для жизни. Они показывают их программе спектры и другую собранную информацию
о планете Х. Далее компьютер опираясь на уже известные данные о других планетах может
выдвенуть теорию пригодна ли эта планета Х для жизни или нет. На каком языке пишут
такие программы? Подойдет ли Java? Заранее спасибо:)
    

Ответы

Ответ 1

Подобные как у NASA программы пишутся на на C - C++.

Отрывок из статьи с tproger:


  Длинный (и более интересный) ответ от инсайдера:
  
  И хотя каждый может
  писать на том, на чем ему удобно, большинство используют C, много
  меньше работников пишут на C++ и уж совсем мало — на Java. Абсолютное
  меньшинство используют ADA, Fortran и Lisp. Assembler используется,
  когда речь идет о необходимости оптимизации или драйвере. Для
  моделирования, как минимум в JPL, большинство поддерживают MatLab, но
  есть и те, кто используют Mathematica (подозреваю, что кто-то
  пользуется даже Maple, но лично я таких людей еще не встречал). В
  целом, ни в каком проекте даже среднего масштаба не используются
  скриптовые языки, и уж тем более, Python, Ruby, Perl и другие, потому
  что эти проекты должны удовлетворять некоторым требованиям.
  
  Приверженность C не лишена смысла. Все крупные проекты организации
  обязательно пишутся на C. Например, код для марсоходов написан на C с
  единственным исключением в виде Gestalt, программного обеспечения для
  визуальной навигации, написанном на C++. Конечно, не лишена смысла и
  разработка ПО на другом языке, но при этом этот код должен быть легко
  портируем на основной язык. На нем же написаны и драйвера для всего
  коммерческого оборудования. С быстрый, для него существует множество
  качественных библиотек, он позволяет писать на очень низком уровне,
  «ближе к железу», что очень полезно. Огромным плюсом является и то,
  что есть много компиляторов, которые придерживаются стандарта C.
  Например, если вы пользуетесь, gcc, то в силу строгости правил
  генерации кода, вы можете быть уверены, что программа будет
  выполняться одинаково на абсолютном большинстве машин. О других языках
  нельзя сказать того же. В частности, я не берусь утверждать, что мало
  компиляторов C++ поддерживают стандарт языка, но несколько лет назад
  это было именно так.


Не думаю, что вы будете писать такие программы, как у NASA. Скорее всего, для ваших
целей подойдет Java.

Про машинное обучение -  для Java есть куча хороших библиотек, в том числе и от Microsoft,
Google, Bing(вроде) по ML.

Про содействие двух программ(когда одна передает данные другой) - Java для этого
отлично подходит, т.к. она отлично подходит для работ с БД. Для Java есть хорошие фраемворки
для работы с БД. Одна программа записывает данные в БД, другая их берет из БД.

Разбить CSV строку датафрейма по запятой и расположить в столбец

#python #pandas #машинное_обучение #numpy #dataframe

В общем задача такая, имеется датафрейм, содержащий данные вида:

Id  Sequence
3   1,3,13...
7   1,2,1,...
8   1,2,4,...
11  1,8,25...
13  1,111,..


Где id - номер последовательности, sequence - сама последовательность.
Задача, взять например первую последовательность и расположить его в столбец и так
со всеми. Количество элементов в последовательности везде разное.

Я делаю так:

#Импортируем необходимые пакеты
import sys
import warnings

import pandas as pd
import numpy as np
from sklearn.metrics import mean_absolute_error, mean_squared_error

import statsmodels.formula.api as smf
import statsmodels.tsa.api as smt
import statsmodels.api as sm
import scipy.stats as scs
from scipy.optimize import minimize

import matplotlib.pyplot as plt

#читаем данные и выводим
dftrain = pd.read_csv('../../data/IntegerSeqTrain.csv', sep=",", index_col=['Id'])
dftrain.head(10)


Выдаст: (то, что sequence выше id меня уже смущает)

   Sequence
Id  
3   1,3,13...
7   1,2,1,...
8   1,2,4,...
11  1,8,25...
13  1,111,...


Далее, собственно само разбиение

#для удобства пишем последовательности в столбец, предварительно разбив по запятой

print(dftrain.shape[1])
i=0
for dfitem in dftrain:
    j=0
    for dfitem2 in dfitem:
        dftrain[j] = dftrain['Sequence'].str.split(',').str.get(j)
        j+=1
    i+=1
#удаляем лишний столбец
dftrain = dftrain.drop('Sequence', 1)
#pd.set_option('max_colwidth', 10)
#что получилось
print(dftrain.head(10))


На выходе:

      0     1      2        3          4          5          6          7
Id                                                                       
3     1     3     13       87       1053      28576    2141733  508147108
7     1     2      1        5          5          1         11         16
8     1     2      4        5          8         10         16         20
11    1     8     25       83        274       2275     132224    1060067
13    1   111  12211  1343211  147753211  162528...  178781...  196659...
15    1     1      1        1          1          1          1          1
16  840  1320   1680     2520       3192       3432       4920       5208



Все записалось в строку, а не в столбец
Количество столбцов сильно сократилось (штук 8-9, хотя их на самом деле гораздо больше)


Как данные красиво разбить и представить в виде столбцов?) Спасибо заранее
Сами данные(train.csv): https://dropmefiles.com/osxrI

Исходник (IPYNB файл): https://dropmefiles.com/cIR4f
    

Ответы

Ответ 1

Решение:

train = pd.read_csv(r'C:\download\train.csv', sep=",", index_col=['Id'])
r = train.Sequence.str.split(',', expand=True).T


Результат:

In [203]: r
Out[203]:
Id    3      7      8       11             13     15     16      ...   227681 227682
           227683                227684 227686 227689 227690
0          1      1      1       1              1      1    840  ...        7   
  1                 0                     0      0      2      5
1          3      2      2       8            111      1   1320  ...        7   
  0                 0                    -1      1      3      7
2         13      1      4      25          12211      1   1680  ...        3   
  1                 4                    -1      9      3    179
3         87      5      5      83        1343211      1   2520  ...        2   
  0              1198                    -1     85      4    229
4       1053      5      8     274      147753211      1   3192  ...        3   
  0           1829388                    -1    801      6    439
5      28576      1     10    2275    16252853211      1   3432  ...        9   
  0       23796035743              10324303   7549      4    557
6    2141733     11     16  132224  1787813853211      1   4920  ...        5   
  0  2142967506078650  -6586524273069171148  71145      5   6113
..       ...    ...    ...     ...            ...    ...    ...  ...      ...   
...               ...                   ...    ...    ...    ...
341     None   None   None    None           None   None   None  ...     None   None
             None                  None   None   None   None
342     None   None   None    None           None   None   None  ...     None   None
             None                  None   None   None   None
343     None   None   None    None           None   None   None  ...     None   None
             None                  None   None   None   None
344     None   None   None    None           None   None   None  ...     None   None
             None                  None   None   None   None
345     None   None   None    None           None   None   None  ...     None   None
             None                  None   None   None   None
346     None   None   None    None           None   None   None  ...     None   None
             None                  None   None   None   None
347     None   None   None    None           None   None   None  ...     None   None
             None                  None   None   None   None

[348 rows x 113845 columns]

In [204]: r.columns
Out[204]:
Int64Index([     3,      7,      8,     11,     13,     15,     16,     18,     20,
    21,
            ...
            227677, 227679, 227680, 227681, 227682, 227683, 227684, 227686, 227689,
227690],
           dtype='int64', name='Id', length=113845)

In [205]: r.shape
Out[205]: (348, 113845)

Множественный классификатор на несбалансированных данных

#r #статистика #машинное_обучение

Нужно построить множественный классификатор (5 классов) на сильно несбалансированной
выборке.

> table(d$class)
    0   0.3   0.5   0.7     1 
12385   736   733    25  1869 


Если просто запустить RandomForest, то ничего получается.
Значит, надо как-то её балансировать. А вот этого я делать-то и не умею.
Все найденные пакеты по балансировке предполагают лишь бинарную классификацию.
Смотрел пакеты:


unbalanced
ROSE


Читал эту статью.

Думал, может в самом RandomForest есть возможность задать cost или сэмплинг — тоже
не нашлось. Как можно решить эту проблему?
    

Ответы

Ответ 1

В пакете "caret" существуют две функции: upSample() и downSample(), которые решают
эту проблему. Балансировать классы необходимо независимо от применяемых методов классификации.  

Обновление

Если отвечать широко,то нужно указать, что балансировка классов один из многих важных
этапов, которые нужно выполнить прежде чем начать обучать модель. Просто перечислю:
выбор и оценка входных переменных, разделение на тренировочную и тестовую выборку(желательно
стратифицированную), балансировка классов(только тренировочного набора), препроцессинг
(нормализация,стандартизация и т.л.), перемешивание тренировочного набора и др. От
качества проведения этих работ на 80% зависит качество получаемого результата моделирования.

Если отвечать так широко потребуется статья хорошего объема. Необходимость балансировки
классов подтверждается многочисленными экспериментами (не только моими) с многими моделями.
Просто сравните результаты классификации одинаковых наборов с и без балансировки Вы
убедитесь в этом сами..


Ответ 2

Вот такая функция решает эту проблему

my.strata <- function(v) {
  tmp <- as.vector(table(v));
  num_clases <- length(tmp);
  min_size <- tmp[order(tmp,decreasing=FALSE)[1]];
  rep(min_size,num_clases);
}


randomForest(.... sampsize=my.strata( ) ... )

Какой метод распознавания актуален для распознавания рукописных букв (кириллица)?

#нейронные_сети #машинное_обучение #распознавание_образов #распознавание_символов

Если стоит задача в распознавании рукописных букв, то какой метод/алгоритм машинного
обучения наиболее актуален и даёт более точные результаты в этой сфере на текущий момент?
К примеру, лучше использовать нейронные сети, или можно вполне обойтись методами машинного
обучения без ИНС? 

Сейчас передо мной стоит задача распознавания рукописных букв (кириллица). Буквы
будут распознаваться по отдельности (не слова целиком). На вход буду подавать таблицы
с различным рукописным написанием букв русского алфавита. Нужна помощь в избрании наиболее
оптимального алгоритма/метода для распознавания рукописных символов.
    

Ответы

Ответ 1

Когда речь идет о распознавании изображений то сразу возникает ответ - Сверточная
нейронная сеть. Ваш случай тому не исключение. Сразу скажу что существует много готовых
решений с уже готовой архитектурой НС, поэтому самому писать ничего не нужно. Если
C++ или Python, советую Tensorflow. Чтобы понять как работают Сверточные НС, почитайте
мой ответ на похожий вопрос.


Ответ 2

Не нужно никаких нейронных сетей, тем более свёрточных.
Берите Tesseract, тренируйте на почерк и используйте.
Сам Tesseract использует НС, но не свёрточную :-)   



Совсем недавно сделал проект - используется Tesseract для выявления charboxes, затем
Tesseract пытается распознать то что выявил, параллельно эти же charboxes пытается
распознать алгоритм на базе OpenCV kNN. 

Для того, что не распознано, есть GUI, в котором можно выделить charbox и указать
вручную что это за символ. В результате формируются данные для тренинга tesseract (то
что он не смог сам распознать и было введено вручную), и данные для тренинга kNN (то
что tesseract распознал и то что вручную введено). 
После >10 тренировок на символ он начинает довольно устойчиво распознаваться обеими
системами.

Как подать массив данных Y из обучающей выборки на вход классифирующей модели?

#python #нейронные_сети #машинное_обучение #keras #tensorflow

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

([0,0,1] первое значение, [0,1,0] второе значение, [1,0,0] третье значение) 

Во всех статьях и книгах данные загружаются уже готовые из репозиториев, но если
создавать собственные данные то возникает проблема.

    import tensorflow as tf
import numpy as np
from keras.models import Sequential
from keras.layers import Input, Dense, Activation
from sklearn import preprocessing
model=Sequential()
X = np.array([[40, 80, 30, 60], [100, 40, 20, 80], [90, 190, 10, 15]])
Y = np.array([[0], [1], [2]])

model = Sequential()
model.add(Dense(16, input_shape=(X.shape[1],)))
model.add(Activation('relu'))
model.add(Dense(16))
model.add(Activation('relu'))
model.add(Dense(3))
model.compile(loss='mean_squared_error', optimizer='Adamax', metrics=['mae'])

model.fit(X,Y,batch_size=3,epochs=1000,
          verbose=1)
a=np.array([40, 80, 30, 60]);
   reshy =a.reshape((1,- 1))
print("test")
print(reshy)
prediction = model.predict(reshy)
print('prediction')
print(prediction)

    

Ответы

Ответ 1

То что вы пытаетесь сделать называется Multilabel Classification. В этом случае массив
Y необходимо преобразовать к One-Hot-Encoded виду:

from keras.utils import to_categorical

Y = to_categorical(Y)


чтобы получилось:

In [76]: Y
Out[76]:
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]], dtype=float32)


Кроме этого надо будет изменить архитектуру НС:

model = Sequential()
model.add(Dense(4, input_shape=(X.shape[1],), activation='relu'))
model.add(BatchNormalization())
model.add(Dense(20, activation='relu'))
model.add(Dense(3, activation='softmax'))

model.compile(loss='categorical_crossentropy', optimizer='Adamax', metrics=['acc'])


NOTE: обратите внимание на loss-function: loss='categorical_crossentropy' и функцию
активации на последнем слое: activation='softmax'.

Вывод:

...
Epoch 47/50
3/3 [==============================] - 0s 0us/step - loss: 0.3294 - acc: 1.0000
Epoch 48/50
3/3 [==============================] - 0s 0us/step - loss: 0.3226 - acc: 1.0000
Epoch 49/50
3/3 [==============================] - 0s 2ms/step - loss: 0.3158 - acc: 1.0000
Epoch 50/50
3/3 [==============================] - 0s 0us/step - loss: 0.3091 - acc: 1.0000
test
[[40 80 30 60]]
prediction
[[0.5021875  0.297052   0.20076045]]


Весь код:



import tensorflow as tf
import numpy as np
from keras.utils import to_categorical
from keras.models import Sequential
from keras.layers import Input, Dense, Activation, BatchNormalization
from sklearn import preprocessing
model=Sequential()
X = np.array([[40, 80, 30, 60], [100, 40, 20, 80], [90, 190, 10, 15]])
Y = np.array([[0], [1], [2]])

Y = to_categorical(Y)

model = Sequential()
model.add(Dense(4, input_shape=(X.shape[1],), activation='relu'))
model.add(BatchNormalization())
model.add(Dense(20, activation='relu'))
model.add(Dense(3, activation='softmax'))

model.compile(loss='categorical_crossentropy', optimizer='Adamax', metrics=['acc'])

model.fit(X,Y,batch_size=3,epochs=100,
          verbose=1)
a=np.array([40, 80, 30, 60]);
reshy =a.reshape((1,- 1))
print("test")
print(reshy)
prediction = model.predict(reshy)
print('prediction')
print(prediction)

AttributeError: 'CatBoostClassifier' object has no attribute 'grid_search'

#python #python_3x #машинное_обучение #catboost

Выводит ошибку AttributeError: 'CatBoostClassifier' object has no attribute 'grid_search',
хотя в документации catboost есть информация о grid_search
https://catboost.ai/docs/concepts/python-reference_catboostclassifier_grid_search.html

python
from catboost import CatBoostClassifier as clf
X = df_features.iloc[:, 3:].fillna(0)
y = df_features['fire_type']
cb_clf = clf(iterations = 1000,
                      depth = 5,
                      loss_function = 'MultiClass',
                      #learning_rate = 0.15
                      )
grid = {'learning_rate':[i/100 for i in range(1,100)],
       'l2_leaf_reg': [1, 3, 5, 7, 9]}
grid_search_result = cb_clf.grid_search(grid, 
                                       X=X, 
                                       y=y, 
                                       plot=True)
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
 in 
      1 grid = {'learning_rate':[i/100 for i in range(1,100)],
      2        'l2_leaf_reg': [1, 3, 5, 7, 9]}
----> 3 grid_search_result = cb_clf.grid_search(grid, 
      4                                        X=X,
      5                                        y=y,

AttributeError: 'CatBoostClassifier' object has no attribute 'grid_search'

    

Ответы

Ответ 1

Текущая версия CatBoost на сегодня - 0.18.1.

Похоже в версии CatBoost 0.12.2 метод grid_search не реализован.

Попробуйте обновить версию CatBoost.

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

#cpp #нейронные_сети #машинное_обучение

Здравствуйте. Пытался реализовать вот этот алгоритм http://robocraft.ru/blog/algorithm/560.html
однако когда провел обучение сети, обнаружил, что выходные данные даже близко не соответствуют
действительности. Где же я допустил ошибку? Или алгоритм по ссылке неправильный? Помогите
разобраться.
double OpenNNL::_changeWeightsByBP(double * trainingInputs, double *trainingOutputs,
double speed, double sample_weight)
{
    double * localGradients = new double[_neuronsCount];
    double * outputs = new double[_neuronsCount];
    double * derivatives = new double[_neuronsCount];

    calculateNeuronsOutputsAndDerivatives(trainingInputs, outputs, derivatives);

    for(int j=0;j<_neuronsPerLayerCount[_layersCount-1];j++)
    {
        localGradients[indexByLayerAndNeuron(_layersCount-1, j)] = trainingOutputs[j]
- outputs[indexByLayerAndNeuron(_layersCount-1, j)];
    }

    if(_layersCount > 1)
    {
        for(int i=_layersCount-2;i>=0;i--)
        {
            for(int j=0;j<_neuronsPerLayerCount[i];j++)
            {
                localGradients[indexByLayerAndNeuron(i, j)] = 0;

                for(int k=0;k<_neuronsPerLayerCount[i+1];k++)
                {
                    localGradients[indexByLayerAndNeuron(i, j)] += _neuronsInputsWeights[indexByLayerNeuronAndInput(i+1,
k, j)]
                                                                    * localGradients[indexByLayerAndNeuron(i+1, k)];
                }
            }
        }
    }

    for(int j=0;j<_neuronsPerLayerCount[0];j++)
    {
        for(int k=0;k<_inputsCount;k++)
        {
            _neuronsInputsWeights[indexByLayerNeuronAndInput(0, j, k)] += speed *
localGradients[indexByLayerAndNeuron(0, j)]
                    * derivatives[indexByLayerAndNeuron(0, j)] * trainingInputs[k];
        }
    }

    for(int i=1;i<_layersCount;i++)
    {
        for(int j=0;j<_neuronsPerLayerCount[i];j++)
        {
            for(int k=0;k<_neuronsPerLayerCount[i-1];k++)
            {
                _neuronsInputsWeights[indexByLayerNeuronAndInput(i, j, k)] += speed
* localGradients[indexByLayerAndNeuron(i, j)]
                        * derivatives[indexByLayerAndNeuron(i, j)] * outputs[indexByLayerAndNeuron(i, j)];
            }
        }
    }

    delete[] localGradients;
    delete[] outputs;
    delete[] derivatives;
}

И в том алгоритме не сказано, как настраивать смещения нейронов. Может кто-нибудь
подсказать как это делать?
Если вам понадобится полный код, то он здесь: https://github.com/NicholasShatokhin/OpenNNL    

Ответы

Ответ 1

ох, нашел ошибку. В последнем цикле нужно было вместо outputs[indexByLayerAndNeuron(i,
j)]; написать: outputs[indexByLayerAndNeuron(i-1, k)];
Все беды от невнимательности.


Ответ 2

Таблица весовых коэффициентов синапсов localGradients должна быть размера _neuronsCount*_neuronsCount.


Ответ 3

Я вот изучил данный алгоритм по ресурсу, который вы предоставили. Так вот, вы, наверное,
"не заметили", что вторая часть полностью посвящена выявлению ошибки в выходном сигнале
Y методом обратного распространения ошибки.
Выходной сигнал сети y сравнивается с желаемым выходным сигналом z, который хранится
в тренировочных данных. 
Разница между этими двумя сигналами называется ошибкой d выходного слоя сети.

Ну, а далее, после этого уже идет выявление нейрона( или связки нейронов одного уровня
), где произошла ошибка( по контрольной сумме, вычисленной функцией f(x) или по суммам
контрольных сумм, если имеем дело со связкой ). Выявление происходит распространении
сигнала ошибки d (вычисленного в шаге обучения) обратно на все нейроны, чьи выходные
сигналы были входящими для последнего нейрона. Собственно, поэтому алгоритм так и называется.

python. Машинное обучение. Прогнозирование

#python #машинное_обучение #scikit_learn #xgboost

Доброго времени суток. Занимался задачами регрессии с использование sclearn и xgboost.
Однако задача прогнозирования слегка отличается, можете ли вы привести пример в каком
виде должны быть данные и пример кода на python для работы c использование xgboost.
В задачах регрессии я подобным образом собирал данные в виде подобного набора строк

1;34;234;234;123;2;321;2;123213;24534;3;278


Где входной вектор был n-1 параметров, а предсказываемое значение - последний столбец.
Насколько я понимаю в задачах прогнозирования, сама строка это один и тот же параметр
который изменяется во времени, в то время как в задачах регрессии несколько различных
параметров по которым предсказываем один. Вопрос - чем отличаются задачи планирования
и регрессии на уровне программирования? 
Т.е.
входные данные имеют вид

    x0        x1        x2        x3        x4        x5        y
  0.392689  0.117810  0.242750  0.931792  0.972802  0.898693  0.429941
  0.569055  0.622889  0.762683  0.095271  0.101407  0.510155  0.542256
  0.939509  0.993534  0.772005  0.164555  0.800897  0.591883  0.190720
  0.284297  0.292773  0.290652  0.045383  0.564894  0.347683  0.014610


где мы предсказываем значение y. И данные имею такой вид:

x1 0.284297  0.292773  0.290652  0.045383  0.564894  0.347683  0.014610  0.961696
x2 0.939509  0.993534  0.772005  0.164555  0.800897  0.591883  0.190720  0.040162


где надо предсказать дальнейшие значения x1, x2, .. в чем отличие в плане кода?

import xgboost as xgb
import pandas as pd
import numpy as np
import math

from sklearn.metrics import confusion_matrix, mean_squared_error
from sklearn.datasets import load_iris, load_digits, load_boston
from sklearn.metrics import mean_absolute_error,mean_squared_error,median_absolute_error,
accuracy_score
df = pd.read_csv('file1.csv',";",header=None)
X_train = df.drop(7,axis=1)
Y_train = df[7]
test_data = pd.read_csv('file2.csv',";",header=None)
X_test = test_data.drop(7,axis=1)
Y_test = test_data[7]
xgb_model = xgb.XGBRegressor(max_depth)
cl = xgb_model.fit(X_train,Y_train)
predictions = cl.predict(X_test)
actuals = Y_test
print(mean_absolute_error(actuals, predictions))
print(mean_squared_error(actuals, predictions))
print(median_absolute_error(actuals, predictions))


Условно данный код, одинаково будет предсказывать и дальнейшее значение x1 для второй
выборки и y - для первой?
    

Ответы

Ответ 1

Ответ на вопрос до правки


  как разбивать на обучающую и проверочную выборку?


Для таких задач идеально подходят модули Pandas и Numpy, которые позволяют работать
без циклов (векторизированные решения) с целыми матрицами и векторами, что на порядки
быстрее по сравнению с обработкой в циклах.

Вот небольшой пример:

import pandas as pd
import numpy as np

# generate random DataFrame (shape: 10, 8)
In [13]: df = pd.DataFrame(np.random.rand(10,8)).add_prefix('x')

In [14]: df.columns = df.columns[:-1].tolist() + ['y']

In [15]: df
Out[15]:
         x0        x1        x2        x3        x4        x5        x6         y
0  0.392689  0.117810  0.242750  0.931792  0.972802  0.898693  0.429941  0.619093
1  0.569055  0.622889  0.762683  0.095271  0.101407  0.510155  0.542256  0.848998
2  0.939509  0.993534  0.772005  0.164555  0.800897  0.591883  0.190720  0.040162
3  0.284297  0.292773  0.290652  0.045383  0.564894  0.347683  0.014610  0.961696
4  0.065868  0.974128  0.749756  0.778895  0.872915  0.585320  0.851837  0.408333
5  0.818768  0.343451  0.985583  0.860080  0.876103  0.554149  0.132387  0.506820
6  0.713177  0.567278  0.587488  0.459199  0.082245  0.677964  0.229960  0.265138
7  0.751670  0.902665  0.353395  0.975563  0.823437  0.742916  0.760047  0.567249
8  0.106809  0.068440  0.075260  0.435980  0.412090  0.226181  0.909518  0.714608
9  0.281475  0.641496  0.695424  0.993351  0.958840  0.457999  0.203841  0.007968


теперь мы можем нарезать данные так как нам удобно

Например если нам нужны все столбцы кроме последнего:

In [16]: df.iloc[:, :-1]
Out[16]:
         x0        x1        x2        x3        x4        x5        x6
0  0.392689  0.117810  0.242750  0.931792  0.972802  0.898693  0.429941
1  0.569055  0.622889  0.762683  0.095271  0.101407  0.510155  0.542256
2  0.939509  0.993534  0.772005  0.164555  0.800897  0.591883  0.190720
3  0.284297  0.292773  0.290652  0.045383  0.564894  0.347683  0.014610
4  0.065868  0.974128  0.749756  0.778895  0.872915  0.585320  0.851837
5  0.818768  0.343451  0.985583  0.860080  0.876103  0.554149  0.132387
6  0.713177  0.567278  0.587488  0.459199  0.082245  0.677964  0.229960
7  0.751670  0.902665  0.353395  0.975563  0.823437  0.742916  0.760047
8  0.106809  0.068440  0.075260  0.435980  0.412090  0.226181  0.909518
9  0.281475  0.641496  0.695424  0.993351  0.958840  0.457999  0.203841


или все столбцы начинающиеся с x:

In [17]: df.filter(regex='^x\d+')
Out[17]:
         x0        x1        x2        x3        x4        x5        x6
0  0.392689  0.117810  0.242750  0.931792  0.972802  0.898693  0.429941
1  0.569055  0.622889  0.762683  0.095271  0.101407  0.510155  0.542256
2  0.939509  0.993534  0.772005  0.164555  0.800897  0.591883  0.190720
3  0.284297  0.292773  0.290652  0.045383  0.564894  0.347683  0.014610
4  0.065868  0.974128  0.749756  0.778895  0.872915  0.585320  0.851837
5  0.818768  0.343451  0.985583  0.860080  0.876103  0.554149  0.132387
6  0.713177  0.567278  0.587488  0.459199  0.082245  0.677964  0.229960
7  0.751670  0.902665  0.353395  0.975563  0.823437  0.742916  0.760047
8  0.106809  0.068440  0.075260  0.435980  0.412090  0.226181  0.909518
9  0.281475  0.641496  0.695424  0.993351  0.958840  0.457999  0.203841


разделяем набор данных на обучающую и проверочную выборки, предварительно перетасовав
данные случайным образом:

In [19]: df_train, df_test = np.split(df.sample(frac=1), [6])

In [20]: df_train
Out[20]:
         x0        x1        x2        x3        x4        x5        x6         y
3  0.284297  0.292773  0.290652  0.045383  0.564894  0.347683  0.014610  0.961696
2  0.939509  0.993534  0.772005  0.164555  0.800897  0.591883  0.190720  0.040162
9  0.281475  0.641496  0.695424  0.993351  0.958840  0.457999  0.203841  0.007968
1  0.569055  0.622889  0.762683  0.095271  0.101407  0.510155  0.542256  0.848998
8  0.106809  0.068440  0.075260  0.435980  0.412090  0.226181  0.909518  0.714608
7  0.751670  0.902665  0.353395  0.975563  0.823437  0.742916  0.760047  0.567249

In [21]: df_test
Out[21]:
         x0        x1        x2        x3        x4        x5        x6         y
4  0.065868  0.974128  0.749756  0.778895  0.872915  0.585320  0.851837  0.408333
0  0.392689  0.117810  0.242750  0.931792  0.972802  0.898693  0.429941  0.619093
6  0.713177  0.567278  0.587488  0.459199  0.082245  0.677964  0.229960  0.265138
5  0.818768  0.343451  0.985583  0.860080  0.876103  0.554149  0.132387  0.506820


PS практически все известные мне библиотеки по машинному обучению принимают в качестве
входных данных Pandas.DataFrame's, Pandas.Series, Numpy.Arra's.

Т.е. что-то вроде:

clf = xgb.XGBClassifier(...)
clf.fit(df_train.filter(regex='^x'), df_train.loc[:, 'y'])

FPR (False Positive Rate), ложные положительные срабатывания

#python #машинное_обучение #big_data

Подскажите, пожалуйста, как посчитать число ложных положительных срабатываний (FPR)
относительно третьего класса для следующей матрицы ошибок (confusion matrix):


    

Ответы

Ответ 1

FP      FP             14+5
FPR = ---- = ------- = ----------------- = 0.106
       N     FP + TN    40+50+23+47+14+5


обозначения:

FPR:  False Positive Rate (FPR)
FP:   False Positive  (FP)
N:    condition negative (N)
TN:   True Negative (TN)


Ответ 2

В хелпе  sklearn есть пример, но вот не могу понять как его верно использовать. На
данный момент у меня csv файл с одним признаком и одним классификаторов (два столбца,
y_true, y_pred)


Ответ 3

Число ложных положительных срабатываний для третьего класса = 14 + 5 = 19

Вычислить скользящее среднее

#python #pandas #машинное_обучение #dataframe #numpy

Есть датафрейм вида.

Id  Sequence
3   1,3,13...
7   1,2,1,...
8   1,2,4,...
11  1,8,25...
13  1,111,..


Где id - номер последовательности, sequence - последовательность с некоторой закономерностью.
Общая задача - угадать следующее число последовательности. Но сейчас я пока разбираюсь
со следующим:

Расположив последовательности в столбец, разбив их по запятой, имеется следующий вывод:

Id  3   7   8   11  13  15  16  18  20  21  ... 227677  227679  227680  227681  227682
 227683  227684  227686  227689  227690
0   1   1   1   1   1   1   840 1   4   1   ... 12  1   1   7   1   0   0   0   2   5
1   3   2   2   8   111 1   1320    2   6   2   ... 50  1   6   7   0   0   -1  1   3   7
2   13  1   4   25  12211   1   1680    7   8   1   ... 113 2   45  3   1   4   -1
 9   3   179


То есть траспонировали датафрейм. Теперь следующая проблема

Метод для вычисления скользящей средней:

def moving_average(series, n):
    return np.average(series[-n:])

moving_average(dftrain[3], 24)


Здесь я подаю пока что только 1 столбец для теста, хотя на самом деле вызов должен
быть в цикле for для каждого существующего столбца. Так вот
В последовательности имеются Слишком большие числа, поэтому необходимо отсечь из
каждого столбца все числа, которые больше скажем некоторого X. Также проблема в том,
что в столбцах значения None, метод не может сложить два None числа, я пытался заменить
None на 0, но по-моему это неверно

dftrain.replace(None, 0)


Для тех кому мало данных. Данная тема является продолжением этой (Тык)

Вопроса 2. Как исключить большие числа из стобцов и как избавиться с проблемой с
None. Чтобы метод скользящее среднее отработал нормально
    

Ответы

Ответ 1

Чтобы заменить числа состоящие из более чем 12 цифр на бесконечность, а строковые
значения None на NaN (Not a Number):

import pandas as pd

def strip_big_nums(col, maxlen=12):
    return pd.to_numeric(np.where(col.str.len() > maxlen, 
                                  'inf', col), 
                         errors='coerce')

train = pd.read_csv(r'C:\download\train.csv', sep=",", index_col=['Id'])
r = train['Sequence'].str.split(',', expand=True)
r = r.apply(lambda col: strip_big_nums(col, 12))


получилось:

In [8]: r
Out[8]:
          0       1        2          3            4             5             6
            7   ...   340  341  342  343  344  345  346  347
Id                                                                              
                ...
3         1.0     3.0     13.0       87.0       1053.0  2.857600e+04  2.141733e+06
 5.081471e+08 ...   NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN
7         1.0     2.0      1.0        5.0          5.0  1.000000e+00  1.100000e+01
 1.600000e+01 ...   NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN
8         1.0     2.0      4.0        5.0          8.0  1.000000e+01  1.600000e+01
 2.000000e+01 ...   NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN
11        1.0     8.0     25.0       83.0        274.0  2.275000e+03  1.322240e+05
 1.060067e+06 ...   NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN
13        1.0   111.0  12211.0  1343211.0  147753211.0  1.625285e+10           inf
          inf ...   NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN
15        1.0     1.0      1.0        1.0          1.0  1.000000e+00  1.000000e+00
 1.000000e+00 ...   NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN
16      840.0  1320.0   1680.0     2520.0       3192.0  3.432000e+03  4.920000e+03
 5.208000e+03 ...   NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN
...       ...     ...      ...        ...          ...           ...           ...
          ... ...   ...  ...  ...  ...  ...  ...  ...  ...
227681    7.0     7.0      3.0        2.0          3.0  9.000000e+00  5.000000e+00
 4.000000e+00 ...   NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN
227682    1.0     0.0      1.0        0.0          0.0  0.000000e+00  0.000000e+00
 0.000000e+00 ...   NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN
227683    0.0     0.0      4.0     1198.0    1829388.0  2.379604e+10           inf
          inf ...   NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN
227684    0.0    -1.0     -1.0       -1.0         -1.0  1.032430e+07           inf
          inf ...   NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN
227686    0.0     1.0      9.0       85.0        801.0  7.549000e+03  7.114500e+04
 6.705010e+05 ...   NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN
227689    2.0     3.0      3.0        4.0          6.0  4.000000e+00  5.000000e+00
 1.000000e+01 ...   NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN
227690    5.0     7.0    179.0      229.0        439.0  5.570000e+02  6.113000e+03
 2.239990e+05 ...   NaN  NaN  NaN  NaN  NaN  NaN  NaN  NaN

[113845 rows x 348 columns]


далее данный DF можно транспонировать:

In [9]: r.T
Out[9]:
Id      3       7       8         11            13      15      16       ...    227681
 227682        227683        227684   227686  227689  227690
0          1.0     1.0     1.0       1.0  1.000000e+00     1.0   840.0   ...    
  7.0     1.0  0.000000e+00  0.000000e+00      0.0     2.0     5.0
1          3.0     2.0     2.0       8.0  1.110000e+02     1.0  1320.0   ...    
  7.0     0.0  0.000000e+00 -1.000000e+00      1.0     3.0     7.0
2         13.0     1.0     4.0      25.0  1.221100e+04     1.0  1680.0   ...    
  3.0     1.0  4.000000e+00 -1.000000e+00      9.0     3.0   179.0
3         87.0     5.0     5.0      83.0  1.343211e+06     1.0  2520.0   ...    
  2.0     0.0  1.198000e+03 -1.000000e+00     85.0     4.0   229.0
4       1053.0     5.0     8.0     274.0  1.477532e+08     1.0  3192.0   ...    
  3.0     0.0  1.829388e+06 -1.000000e+00    801.0     6.0   439.0
5      28576.0     1.0    10.0    2275.0  1.625285e+10     1.0  3432.0   ...    
  9.0     0.0  2.379604e+10  1.032430e+07   7549.0     4.0   557.0
6    2141733.0    11.0    16.0  132224.0           inf     1.0  4920.0   ...    
  5.0     0.0           inf           inf  71145.0     5.0  6113.0
..         ...     ...     ...       ...           ...     ...     ...   ...    
  ...     ...           ...           ...      ...     ...     ...
341        NaN     NaN     NaN       NaN           NaN     NaN     NaN   ...    
  NaN     NaN           NaN           NaN      NaN     NaN     NaN
342        NaN     NaN     NaN       NaN           NaN     NaN     NaN   ...    
  NaN     NaN           NaN           NaN      NaN     NaN     NaN
343        NaN     NaN     NaN       NaN           NaN     NaN     NaN   ...    
  NaN     NaN           NaN           NaN      NaN     NaN     NaN
344        NaN     NaN     NaN       NaN           NaN     NaN     NaN   ...    
  NaN     NaN           NaN           NaN      NaN     NaN     NaN
345        NaN     NaN     NaN       NaN           NaN     NaN     NaN   ...    
  NaN     NaN           NaN           NaN      NaN     NaN     NaN
346        NaN     NaN     NaN       NaN           NaN     NaN     NaN   ...    
  NaN     NaN           NaN           NaN      NaN     NaN     NaN
347        NaN     NaN     NaN       NaN           NaN     NaN     NaN   ...    
  NaN     NaN           NaN           NaN      NaN     NaN     NaN

[348 rows x 113845 columns]

Обучение нейронной сети теореме Пифагора

#python #нейронные_сети #машинное_обучение #keras #обучение_с_подкреплением

Хочу обучить НС теореме Пифагора. Всё вроде правильно сделал, нормализовал данные,
модель правильная, а вот в чём ошибка не понятно..

import numpy as np

from keras.models import Sequential
from keras.layers.core import Dense, Activation
from keras.utils import np_utils

np.random.seed()

NB_EPOCH = 500
VERBOSE = 1

X_in = [[ 0 , 44 ], [ 0 , 18 ], [ 38 , 0 ], [ 48 , 14 ], [ 0 , 36 ], [ 14 , 0 ],
[ 34 , 0 ], [ 0 , 0 ], [ 0 , 38 ], [ 32 , 0 ], [ 28 , 0 ], [ 36 , 0 ], [ 20 , 48 ],
[ 0 , 6 ], [ 0 , 20 ], [ 0 , 42 ], [ 0 , 8 ], [ 24 , 32 ], [ 4 , 0 ], [ 6 , 8 ], [
24 , 10 ], [ 0 , 22 ], [ 16 , 12 ], [ 30 , 40 ], [ 0 , 32 ], [ 0 , 32 ], [ 16 , 0 ],
[ 48 , 20 ], [ 0 , 8 ], [ 32 , 0 ], [ 0 , 46 ], [ 0 , 22 ], [ 0 , 8 ], [ 10 , 24 ],
[ 0 , 36 ], [ 14 , 0 ], [ 0 , 22 ], [ 42 , 0 ], [ 16 , 12 ], [ 40 , 30 ], [ 44 , 0
], [ 40 , 0 ], [ 34 , 0 ], [ 0 , 32 ], [ 40 , 30 ], [ 32 , 0 ], [ 0 , 30 ], [ 24 ,
18 ], [ 0 , 26 ], [ 22 , 0 ], [ 0 , 4 ], [ 16 , 0 ], [ 10 , 0 ], [ 0 , 32 ], [ 0 ,
42 ], [ 2 , 0 ], [ 0 , 38 ], [ 32 , 24 ], [ 48 , 0 ], [ 20 , 0 ], [ 0 , 18 ], [ 0 ,
38 ], [ 14 , 48 ], [ 40 , 42 ], [ 16 , 12 ], [ 26 , 0 ], [ 0 , 20 ], [ 40 , 30 ], [
16 , 30 ], [ 36 , 48 ], [ 36 , 0 ], [ 18 , 24 ], [ 34 , 0 ], [ 16 , 0 ], [ 0 , 24 ],
[ 0 , 24 ], [ 0 , 18 ], [ 38 , 0 ], [ 28 , 0 ], [ 0 , 34 ], [ 0 , 36 ], [ 24 , 32 ],
[ 16 , 30 ], [ 40 , 30 ], [ 24 , 0 ], [ 0 , 14 ], [ 8 , 6 ], [ 12 , 0 ], [ 16 , 0 ],
[ 16 , 30 ], [ 48 , 14 ], [ 0 , 30 ], [ 38 , 0 ], [ 38 , 0 ], [ 0 , 8 ], [ 36 , 48
], [ 0 , 32 ], [ 10 , 24 ], [ 46 , 0 ], [ 24 , 10 ], [ 30 , 0 ], [ 0 , 48 ], [ 40 ,
0 ], [ 42 , 0 ], [ 32 , 24 ], [ 32 , 0 ], [ 12 , 16 ], [ 0 , 4 ], [ 0 , 28 ], [ 32
, 0 ], [ 40 , 42 ], [ 46 , 0 ], [ 0 , 24 ], [ 30 , 16 ], [ 36 , 48 ], [ 40 , 0 ], [
24 , 0 ], [ 0 , 22 ], [ 40 , 42 ], [ 10 , 24 ], [ 0 , 16 ], [ 14 , 48 ], [ 22 , 0 ],
[ 0 , 22 ], [ 30 , 0 ], [ 0 , 2 ], [ 48 , 20 ], [ 6 , 0 ], [ 6 , 0 ], [ 28 , 0 ], [
20 , 0 ], [ 0 , 40 ], [ 42 , 0 ], [ 48 , 36 ], [ 14 , 0 ], [ 10 , 24 ], [ 0 , 30 ],
[ 48 , 20 ], [ 40 , 30 ], [ 0 , 0 ], [ 42 , 40 ], [ 0 , 48 ], [ 32 , 24 ]]
X_answer = [[44] ,[18] ,[38] ,[50] ,[36] ,[14] ,[34] ,[0] ,[38] ,[32] ,[28] ,[36]
,[52] ,[6] ,[20] ,[42] ,[8] ,[40] ,[4] ,[10] ,[26] ,[22] ,[20] ,[50] ,[32] ,[32] ,[16]
,[52] ,[8] ,[32] ,[46] ,[22] ,[8] ,[26] ,[36] ,[14] ,[22] ,[42] ,[20] ,[50] ,[44] ,[40]
,[34] ,[32] ,[50] ,[32] ,[30] ,[30] ,[26] ,[22] ,[4] ,[16] ,[10] ,[32] ,[42] ,[2] ,[38]
,[40] ,[48] ,[20] ,[18] ,[38] ,[50] ,[58] ,[20] ,[26] ,[20] ,[50] ,[34] ,[60] ,[36]
,[30] ,[34] ,[16] ,[24] ,[24] ,[18] ,[38] ,[28] ,[34] ,[36] ,[40] ,[34] ,[50] ,[24]
,[14] ,[10] ,[12] ,[16] ,[34] ,[50] ,[30] ,[38] ,[38] ,[8] ,[60] ,[32] ,[26] ,[46]
,[26] ,[30] ,[48] ,[40] ,[42] ,[40] ,[32] ,[20] ,[4] ,[28] ,[32] ,[58] ,[46] ,[24]
,[34] ,[60] ,[40] ,[24] ,[22] ,[58] ,[26] ,[16] ,[50] ,[22] ,[22] ,[30] ,[2] ,[52]
,[6] ,[6] ,[28] ,[20] ,[40] ,[42] ,[60] ,[14] ,[26] ,[30] ,[52] ,[50] ,[0] ,[58] ,[48]
,[40]]
X_in = np.asarray(X_in, dtype=np.float32)
X_answer = np.asarray(X_answer, dtype=np.float32)

X_in /= np.amax(X_in)
X_answer /= np.amax(X_answer)

model = Sequential()
model.add(Dense(10, input_dim = 2, activation='relu'))
model.add(Dense(10, activation='relu'))
model.add(Dense(1, activation='softmax'))

model.compile(loss='mean_squared_error', optimizer='adam', metrics=['accuracy'])

history = model.fit(X_in, X_answer, epochs=NB_EPOCH, verbose=VERBOSE)


Что до 100 эпох, что до 500 один и тот же результат:

Epoch 1/100
143/143 [==============================] - 0s 2ms/step - loss: 0.2966 - acc: 0.0280
Epoch 2/100
143/143 [==============================] - 0s 52us/step - loss: 0.2966 - acc: 0.0280
Epoch 3/100
143/143 [==============================] - 0s 52us/step - loss: 0.2966 - acc: 0.0280
Epoch 4/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 5/100
143/143 [==============================] - 0s 52us/step - loss: 0.2966 - acc: 0.0280
Epoch 6/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 7/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 8/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 9/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 10/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 11/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 12/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 13/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 14/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 15/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 16/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 17/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 18/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 19/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 20/100
143/143 [==============================] - 0s 35us/step - loss: 0.2966 - acc: 0.0280
Epoch 21/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 22/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 23/100
143/143 [==============================] - 0s 35us/step - loss: 0.2966 - acc: 0.0280
Epoch 24/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 25/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 26/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 27/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 28/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 29/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 30/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 31/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 32/100
143/143 [==============================] - 0s 52us/step - loss: 0.2966 - acc: 0.0280
Epoch 33/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 34/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 35/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 36/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 37/100
143/143 [==============================] - 0s 49us/step - loss: 0.2966 - acc: 0.0280
Epoch 38/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 39/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 40/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 41/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 42/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 43/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 44/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 45/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 46/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 47/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 48/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 49/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 50/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 51/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 52/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 53/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 54/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 55/100
143/143 [==============================] - 0s 49us/step - loss: 0.2966 - acc: 0.0280
Epoch 56/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 57/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 58/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 59/100
143/143 [==============================] - 0s 35us/step - loss: 0.2966 - acc: 0.0280
Epoch 60/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 61/100
143/143 [==============================] - 0s 35us/step - loss: 0.2966 - acc: 0.0280
Epoch 62/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 63/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 64/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 65/100
143/143 [==============================] - 0s 52us/step - loss: 0.2966 - acc: 0.0280
Epoch 66/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 67/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 68/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 69/100
143/143 [==============================] - 0s 52us/step - loss: 0.2966 - acc: 0.0280
Epoch 70/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 71/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 72/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 73/100
143/143 [==============================] - 0s 39us/step - loss: 0.2966 - acc: 0.0280
Epoch 74/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 75/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 76/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 77/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 78/100
143/143 [==============================] - 0s 49us/step - loss: 0.2966 - acc: 0.0280
Epoch 79/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 80/100
143/143 [==============================] - 0s 49us/step - loss: 0.2966 - acc: 0.0280
Epoch 81/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 82/100
143/143 [==============================] - 0s 35us/step - loss: 0.2966 - acc: 0.0280
Epoch 83/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 84/100
143/143 [==============================] - 0s 35us/step - loss: 0.2966 - acc: 0.0280
Epoch 85/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 86/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 87/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 88/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 89/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 90/100
143/143 [==============================] - 0s 49us/step - loss: 0.2966 - acc: 0.0280
Epoch 91/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 92/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 93/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280
Epoch 94/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 95/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 96/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 97/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 98/100
143/143 [==============================] - 0s 45us/step - loss: 0.2966 - acc: 0.0280
Epoch 99/100
143/143 [==============================] - 0s 42us/step - loss: 0.2966 - acc: 0.0280
Epoch 100/100
143/143 [==============================] - 0s 38us/step - loss: 0.2966 - acc: 0.0280

    

Ответы

Ответ 1

Как уже сказал @L.Murashov функция активации softmax применяется в задачах мультиклассовой
классификации - она помогает посчитать вероятности принадлежности образца каждому из
классов.

Есть еще несколько моментов, на которые стоит обратить внимание:


В обучающей выборке слишком много (около половины) нулевых значений - это вырожденный
случай для теоремы Пифагора, когда одна из сторон треугольника имеет нулевую длину.
Для того, чтобы лучше обучить модель можно выборку взять побольше - в вашем случае
не проблема сгенерировать столько данных сколько нужно.
Для данной (простой) задачи хватит одного скрытого слоя
В качестве функции активации выходного слоя можно использовать linear
В качестве функции потери и метрики можно выбрать mean_squared_error  




Пример:

import numpy as np
from keras.models import Sequential
from keras.layers.core import Dense, Activation

N = 5000
np.random.seed(1234)
X = np.random.randint(0, 50, size=(N,2))
y = np.linalg.norm(X, axis=1)

NB_EPOCHS = 100
VERBOSE = 1

model = Sequential()
model.add(Dense(20, input_dim = 2, activation='relu'))
model.add(Dense(1, activation='linear'))
model.compile(loss='mse', optimizer='adam', metrics=['mean_squared_error'])
model.fit(X, y, epochs=NB_EPOCHS, verbose=VERBOSE)


Обучение:

...
5000/5000 [==============================] - 0s 22us/step - loss: 0.0057 - mean_squared_error:
0.0057
Epoch 98/100
5000/5000 [==============================] - 0s 22us/step - loss: 0.0048 - mean_squared_error:
0.0048
Epoch 99/100
5000/5000 [==============================] - 0s 22us/step - loss: 0.0045 - mean_squared_error:
0.0045
Epoch 100/100
5000/5000 [==============================] - 0s 22us/step - loss: 0.0043 - mean_squared_error:
0.0043
Out[70]: 


Предсказание:

In [71]: model.predict(np.array([[3,4], [10,10], [5,6]]))
Out[71]:
array([[ 5.018393],
       [14.130004],
       [ 7.841759]], dtype=float32)


Ответ 2

У вас неправильная функция активации на последнем слое. Softmax ограничен [0..1]

model.add(Dense(1, activation='softmax'))


заменить на

# После слоя не применяется функция активации
model.add(Dense(1))


Еще accuracy здесь бесполезна т.к. задача регрессии.

metrics=['accuracy']

как обучать модель если использовал KFold cross validation

#python #pandas #dataframe #машинное_обучение #scikit_learn

после разбиения сета методом ''sklearn.cross_validation.KFold'' у меня есть 6 чанков
(3 train ,3 test,+ ответы для них)  . Существует ли функция , с помощью  которой можно
обучить алгоритм просто закинуть все чанки или нужно постоянно писать  :

Vasya=model.fit(chank1,answer1)
a1=model.predict(Vasya,answer_t_1)


?
    

Ответы

Ответ 1

Если хотите научиться пользоваться KFold - вот небольшой пример:

kf = KFold(n_splits=N)
for train, test in kf.split(X):
    print("%s %s" % (train, test))
    X_train, X_test, y_train, y_test = X[train], X[test], y[train], y[test]
    model.fit(X_train, y_train)
    ...


вариант попроще:

from sklearn.model_selection import cross_val_score

kf = KFold(n_splits=N)
results = cross_val_score(model, X, y, cv=kf)


Ответ 2

Кросвалидация
встроена в sklearn. Если нужно протестировать модель на разных фолдах с использованием
KFold то самы простой способ это cross_val_score или cross_val_predict


cross_val_score(model,chank1,answer1,cv=n) даст оценки для фолдов
cross_val_score(model,chank1,answer1,cv=n) даст все предсказания по X


Но обычно кросвалидацией подбирают гиперпараметры для этого есть
GridSearchCV которая можно отдать сетку паметров и "сама" подберет лучшуую комбинацию.

NB у всех этих функций есть параметр n_jobs вот он и стоит того, чтобы не писать
циклы ручками n_jobs = -1 положит машину на время проведения работ загрузив все процы
- это, то что в python не так просто сделать.

Нейросети и машинное обучение - это два разных понятия?

#нейронные_сети #машинное_обучение

Нейросети и машинное обучение - это два разных понятия? Ведь машинное обучение производится
на заранее  подготовленных данных, а для нейросети они вроде бы не нужны - я встпечал
такое определение: Нейросеть - это алгоритм, который спсобен сам уточнять входной параметр.
    

Ответы

Ответ 1

Вы задали слишком философский вопрос. Каждый на него ответит по-своему. Моём мнение
Вы можете узнать ниже.

Сейчас нейросети (НС) воспринимаются многими как панацея. Приведу пример. Если Вы
спросите: "Как можно решить какую-либо задачу, поставленную нечётко?" Например, как
узнать, в какой момент произойдёт отток клиентов в банке, либо же, в какой момент Петечкин
Василий Петрович перестанет платить кредит. Скорее всего Вас отошлют к нейросетям и
скажут: а возьмите-ка ваши данные подайте на вход нейронной сети и будет Вам счастье.
Этот подход имеет место быть и он неплох, особенно, когда следует получить быстрый
результат в условиях ограниченного времени. Скорее всего Вы получите приемлемое качество
при наличии небольшой сноровки работы с НС. 

Но вот на вопрос, что можно использовать помимо НС, скорее всего Вы получите в ответ
задумчивое молчание. После чего, вероятно, человек выпалит фразу, в которой будет фигурировать
слово "регрессия" или "метод главных компонент". Да, всё это прекрасные методы, но
часто люди ими и ограничиваются.

Многие модели эквивалетны друг другу. Так, регрессию можно представить нейросетью,
а нейросеть регрессией. И ничего здесь странного нет. Также и с другими методами.

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

Отвечая на Ваш вопрос про машинное обучение и НС. Машинное обучение -- это набор
математических методов прикладной математики, которые, в большинстве  своём проходят
в курсах высшей школы (численные методы, методы оптимизации, статистика, анализ, дискретная
математика и другие). НС -- есть метод прикладной математики, который направлен на
решение определённого класса задач. Следовательно, НС -- это семейство алгоритмов,
являющихся частью машинного обучения, которые, как правило, можно отнести к численным
методам и методам оптимизации.


Ответ 2

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


Ответ 3

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

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

Источник


Ответ 4

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