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

#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)

Какие могут быть пути улучшения обобщающей способности ИНС на базе 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)


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

Алгоритм сортировки используя нейросеть

#алгоритм #нейронные_сети

Подскажите, пожалуйста, хорошие статьи на тему "Сортировка на нейросети".
Базу про нейросети почитал. Что такое "однослойный перцептрон" представляю.
Почему именно сортировка? Просто разбирают задание, в котором требуется написать
алгоритм сортировки чисел, используя нейросеть. При этом весовые коэффиценты должны
быть "аналитически" настраиваемыми.
Если вы можете что-то посоветовать по поводу конкретно этого задания, то буду благодарен.    

Ответы

Ответ 1

Проблема сортировки на нейронной сети неоднократно изучалась; к примеру см. Lin,
Hsu (1997) и Tamburatzis (1999).

Распознавание символов и работа с изображенями

#c_sharp #изображения #нейронные_сети

Имеется нейронная сеть, способная распознавать символы. При загрузке рисунка из Paint
размеров 150 на 150 всё работает нормально.Фон здесь белый, буква нарисована чёрным цветом.



При загрузке картинки ( также 150 на 150) с прозрачным фоном программа работает "наоборот"

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

Первая и вторая картинка имеет одинаковый формат .png

Каким образом можно настроить программу для работы с изображением на прозрачном фоне?

Метод считывания картинки

public void get(Bitmap map) 
    {
        for (int x = 0; x < mbut.GetLength(0); x++)
        {
            for (int y = 0; y < mbut.GetLength(1); y++)
            {
                Color col = map.GetPixel(x, y);
                if (col.R == 0 && col.B == 0 && col.G == 0)
                    mbut[x, y] = true;
                else label9.Text = "Цвет пикселя номер " + x + ":" + y+" "+ Convert.ToString(map.GetPixel(x, y));
            }
        }     
        label10.Text = "Цвет первого пикселя: " + Convert.ToString(map.GetPixel(0, 0));
    }


Метод прорисовки весов

 public void draw(int n)
    {
        using (Bitmap map = new Bitmap(150, 150))
        {
            for (int x = 0; x < weight.GetLength(0); x++)
            {
                for (int y = 0; y < weight.GetLength(1); y++)
                {
                    if (weight[x, y] > 1)
                    {                            
                        map.SetPixel(x, y, Color.Black);
                    }         
                }
            }
            map.Save(String.Format("Pictures/{0}.png",n), System.Drawing.Imaging.ImageFormat.Png);
        }
    }

    

Ответы

Ответ 1

Предполагаю что проблема в работе с каналами цветного изображения в цветовой схеме ARGB. 
Когда Paint сохраняет изображение, он приводит её к RGB и проблем не возникает.
При других редакторах цветовая схема остается ARGB.

Вот какая складывается ситуация:

Вы берете цветовой схемы, в первом случае это RGB, и по каналу R определяете черный
это или не черный. В итоге инициализация проходит успешно.

Во втором случае с схемой ARGB, в которой изображение имеет прозрачность, первым
каналом является A - alpha(оно-же прозрачность) вы пытаетесь по прозрачным цветам определить
черный и сталкиваетесь с ситуацией когда все пиксели которые прозрачны - получают черный
цвет а те которые не прозрачны остаются белыми. В этом и кроется секрет вашей хитроумной
инверсии :)


Ответ 2

if (col.R == 0 && col.B == 0 && col.G == 0)



Не хватает проверки && col.A != 0. Видимо, paint сохранил прозрачный фон всеми ноликами.

Распознавание символов и работа с изображенями

#c_sharp #изображения #нейронные_сети

Имеется нейронная сеть, способная распознавать символы. При загрузке рисунка из Paint
размеров 150 на 150 всё работает нормально.Фон здесь белый, буква нарисована чёрным цветом.



При загрузке картинки ( также 150 на 150) с прозрачным фоном программа работает "наоборот"

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

Первая и вторая картинка имеет одинаковый формат .png

Каким образом можно настроить программу для работы с изображением на прозрачном фоне?

Метод считывания картинки

public void get(Bitmap map) 
    {
        for (int x = 0; x < mbut.GetLength(0); x++)
        {
            for (int y = 0; y < mbut.GetLength(1); y++)
            {
                Color col = map.GetPixel(x, y);
                if (col.R == 0 && col.B == 0 && col.G == 0)
                    mbut[x, y] = true;
                else label9.Text = "Цвет пикселя номер " + x + ":" + y+" "+ Convert.ToString(map.GetPixel(x, y));
            }
        }     
        label10.Text = "Цвет первого пикселя: " + Convert.ToString(map.GetPixel(0, 0));
    }


Метод прорисовки весов

 public void draw(int n)
    {
        using (Bitmap map = new Bitmap(150, 150))
        {
            for (int x = 0; x < weight.GetLength(0); x++)
            {
                for (int y = 0; y < weight.GetLength(1); y++)
                {
                    if (weight[x, y] > 1)
                    {                            
                        map.SetPixel(x, y, Color.Black);
                    }         
                }
            }
            map.Save(String.Format("Pictures/{0}.png",n), System.Drawing.Imaging.ImageFormat.Png);
        }
    }

    

Ответы

Ответ 1

Предполагаю что проблема в работе с каналами цветного изображения в цветовой схеме ARGB. 
Когда Paint сохраняет изображение, он приводит её к RGB и проблем не возникает.
При других редакторах цветовая схема остается ARGB.

Вот какая складывается ситуация:

Вы берете цветовой схемы, в первом случае это RGB, и по каналу R определяете черный
это или не черный. В итоге инициализация проходит успешно.

Во втором случае с схемой ARGB, в которой изображение имеет прозрачность, первым
каналом является A - alpha(оно-же прозрачность) вы пытаетесь по прозрачным цветам определить
черный и сталкиваетесь с ситуацией когда все пиксели которые прозрачны - получают черный
цвет а те которые не прозрачны остаются белыми. В этом и кроется секрет вашей хитроумной
инверсии :)


Ответ 2

if (col.R == 0 && col.B == 0 && col.G == 0)



Не хватает проверки && col.A != 0. Видимо, paint сохранил прозрачный фон всеми ноликами.

Анализ изображения - имеется ли на нем человек

#python #python_3x #нейронные_сети

Как провести анализ изображения - имеется ли на нем человек?

Для проекта нужна программа, которая будет распознавать фото на аватарке и анализировать,
если на фото человек.  

Что можно использовать?
    

Ответы

Ответ 1

Это очень обширная задача. Лучше будет нанять специалиста по "Deep Learning" если
вы никогда этим не занимались.

Если все же решите заняться этим самому то вот несколько разрозненных советов:

Скорее всего вам понадобиться большой набор тренировочных данных (изображений) для
обучения. Эти данные должны быть заведомо размечены - т.е. в вашем случае достаточно
будет разделить все изображения на две категории - там где присутствуют люди (True
или 1) и там где их нет (False или 0). 

Кроме того вам надо будет всеръез изучить что из себя представляют "Сверточные Нейронные
Сети" (CNN - "Convolutional Neural Networks") и как ими пользоваться.

Вот неплохая подборка рабочих примеров с использованием библиотеки Keras - смотрите
секцию "Working with images"

В мире CNN существует много различных архитектур, которые показывают различные результаты
(точность классификации / предсказаний). Вот небольшой список хорошо зарекомендовавших
себя CNN архитектур:


VGG16
VGG19
ResNet50
Inception V3
GoogLeNet
Inception-ResNet-v2


Также не помешало бы пройти несколько курсов по "Machine Learning" и по "Deep Learning"
для того, чтобы более-менее понимать как это все работает.

Удачи!

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)

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

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

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

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

Ответы

Ответ 1

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


Ответ 2

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



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

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

Формат WAV и нейронная сеть

#c_sharp #нейронные_сети

Как wav формат правильно разобрать, чтобы ввести в нейронную сеть, и, какую сеть
выбрать для лучшего распознавания?    

Ответы

Ответ 1

Например, есть такой вариант для распознавания голоса (голосовых команд):
Вы разбиваете свой файл на N-кусочков, по секунде, например, каждый. Разбивка заключается
в наложении оконной функции. После этого, каждый из кусочков файла подвергается сглаживанию,
т.е. накладывается окно, например Хэмминга, которое даст более выраженную гармоническую
часть.

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


Ответ 2

Для работы со звуком подойдут сверточные сети(CNN) и рекуррентные сети(rnn,lstm).
В качестве векторов признаков можно использовать спектр, FBANK, MFCC, LPC. Все зависит
от конкретной задачи.

Подготовка данных для распознавания речи нейронной сетью

#алгоритм #аудио #нейронные_сети

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

Допустим есть у меня какая-то сеть с N входами и M выходами. И есть звуковой сигнал
с каким-то текстом. Как все это заставить работать вместе?

Получили мы, допустим, с помощью преобразования Фурье спектр. Ну можем как-то нарезать
звуковой сигнал на какие-то мелкие кусочки. Опять же, как их выбрать длину куска? И
что делать дальше? Что подавать на вход сети? И что сеть на выходе обычно дает? Буквы,
соответствующие звукам или еще что-либо? (Допустим, стоит задача получить произнесенное
предложение в текстовом виде)

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

Ответы

Ответ 1

Тема слишком обширная для краткого ответа - ваш вопрос - это повод для хорошего исследования.
Однако, гипотезы выдвигать никто не запрещает.

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



Здесь изображен сигнал с нормализованной амплитудой + плюс я обрезал паузу в начале
записи. Как видно, между слогами очень осязаемая пауза и весь текст можно последовательно
нарезать на такие отрезки - на мой взгляд с такими маленькими единицами информации
работать легче, чем целиком со словами. Далее эти куски можно выровнять по длительности
(по количеству сэмплов), вычислить коэффициенты и обучать или распознавать. Обучение
это также отдельный большой вопрос, как и распознавание, а точнее, что делать после
распознавания. Например, слово распозналось неверно и его нет в словаре.

Гибкость генетического алгоритма

#алгоритм #нейронные_сети #теория #генетический_алгоритм

Как сделать правильно гибкость генетического алгоритма (умоляю не советуйте A*),
ну вот на примитивном примере движении машины к цели, обходя препятствие:

Что у нас есть :


  
  У нас есть машина, она может двигать вперёд, влево, вправо, назад.
  Есть препятствие, если машина в него въезжает она ломается.
  Ещё есть цель, до которой наша машина должна добраться.
  




Так вот, вопрос в чём, как я понимаю наш генетический алгоритм проложит определённый
маршрут нашей машины до цели (рис. 1), но если мы изменим карту (рис. 2), то этот же
генетический алгоритм не доберётся до нашего места назначения, он просто сначала пойдёт
по тому же пути и потом опять начнёт грубо говоря подбором (скрещиванием) подбирать
маршрут, а как сделать чтобы он уже мог уверенно идти к цели основываясь на опыте (рис. 3) ?





UPD :


    

Ответы

Ответ 1

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

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

Конкретно для этой задачи можно просто брать за первоначальный маршрут прямую линию
из начальной в конечную точку, дальше начинать "мутировать" этот маршрут: добавлять/удалять
узлы, смещать их, и т.д. В простых случаях "скрещивать" маршруты между собой не обязательно,
но для сложных лабиринтов это может дать какие-то бонусы (можно с этим поэкспериментировать).
В общем-то, если в исходном пути по прямой нет препятствий, то этот маршрут в итоге
и выиграет. Если препятствия попадутся, то за счет штрафа за пересечение препятствий
будет выбран другой маршрут, где препятствий нет.

Целевая функция - длина пути + штраф за пересечение препятствий (можно задать, что
он будет зависеть от расстояния до края препятствия). Можно еще добавить штраф за количество
узлов (чтобы они не сильно "плодились"), но он должен быть намного меньше штрафа за
препятствия, иначе маршрут будет сходиться к прямой линии вне зависимости от наличия
препятствий (тоже можно поэкспериментировать величиной штрафа).

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

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

Применение нейронных сетей и ИИ в Мобильных Приложениях.

#java #android #нейронные_сети #искусственный_интеллект

Здравствуйте, хотелось бы узнать , примеры приложений , да и в целом, где и как применяются
нейронные сети и ИИ в приложениях. 
Сам пишу на java под android, и хотелось бы узнать, реально ли совмещать данные занятия:"Изучение
нейронных сетей и ИИ и практиковаться и внедрять их в Мобильных Приложениях?
    

Ответы

Ответ 1

Как показала моя практика это возможно, однако писать нейросеть в самом приложении
не самая лучшая идея. Когда начинал изучение нейросетей, с 0 написал свою нейросеть
в виде библеотеки для андроид. Использую ее в 2 своих проектах: анализ рынка акций
и анализ предпочтений фильмов. В обоих случаях все работает, но дает очень большую
нагрузку на ЦП телефона и он буквально становиться сковордкой на которй можно жарить
яишницу. Если кончено сеть не глубокая и данных для обработки не много то можно и так,
но почитав кучу статей понял что намного лучше релизвать нейросеть отдельно на сервере
и общаться с ней по сети. На мой взгляд лучший фреймворк для НС это TensorFlow от гугла.


Ответ 2

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

Пример реализации нейросетей на Java

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

нейронная сеть типа-многослойный перцептрон

Проблема с нейронной сетью Хопфилда (анализ текста)

#delphi #нейронные_сети #neuralbase

Здравствуйте, товарищи!    

Я решил поизучать да поэкспериментировать с нейронными сетями и столкнулся с проблемой.
А дело вот в чем: пытаюсь сделать приложение, которое будет анализировать слова, пущенные
на выход нейронной сети хопфилда, со словами, хранимыми в обучающей выборке.
Как все происходит:

Нейронная сеть Хопфилда обучается словам, которые хранятся в ini-файле (слова разбиваются
на буквы, каждая буква представляется уникальной шестизначной последовательностью 1 и 0) 
Каждая буква слова, которое нужно распознать, разбивается на уникальную шестизначную
последовательность 1 и 0
Эти коды букв распознаваемого слова соединяются в кучу и подаются на выходы нейронной
сети хопфилда 
дальше, в идеале, выходные данные должны анализироваться, после чего, нейро сеть
должна выдать наиболее похожий результат из тех, что она "знает" 
Заранее обученная нейронная сеть обратного распространения просматривает, выданные
нейро сетью хапфилда, коды символов и преобразует их в буквы

Однако что-то у меня с сетью  хопфилда не так. Она выбирает одно, какое-то, слово
из обучающей выборки и всегда подставляет его. Чувствую, что я где-то накосячил =/
критику, типа "зачем так мудрить, зачем использовать нейро сеть, бла-бла-бла" фтопку.
собственно код
// Очистить сведения о примерах
NeuralNetHopf1.ResetPatterns;
// Устанавливаем размер вектора для Хопфилда
SetLength(zInputVector, 36);
// Создаем стринглист
Slova:= TStringList.Create;
// Создаем ини файл
IniFile1:= TIniFile.Create('G:\Neural\Project 1\HopfData.ini');
// Заносим слова в стринглист
IniFile1.ReadSection('слова', Slova);

// Пробегаем все слова
for i := 0 to Slova.Count - 1 do
 begin
  f:= 0; // обнуляем элемент вектора
  // Пробегаем каждую букву в слове
  for h := 1 to Length(Slova[i]) do //количество букв в слове
    begin
      // смотрим код буквы и заносим его в вектор
      for z := 0 to 5 do  // z - количество символов буквы. всего 6
        begin
          if Array1[ord(Slova[i][h]), z] = 1 then // в этом массиве хранятся коды
букв. например: буква "а" с анси кодом 1072 имеет личный код 100000
            zInputVector[f]:= 1
          else
            zInputVector[f]:= -1;
          // Переходим на следущее поле вектора
          inc(f); // переходим на след. элемент вектора
        end;
    end;

  // Добавляем пример для выборки
  NeuralNetHopf1.AddPattern(zInputVector);

 end;

// Инициализируем веса
NeuralNetHopf1.InitWeights;

Memo.Lines.Clear;

// подаем сигналы на выходы сети хопфилда
z:= 0;
for I := 1 to Length(Edit1.Text) do
 for h := 0 to 5 do
  begin
    // в массиве коды символов
    if Array1[ord(Edit1.Text[i]), h] = 1 then
      NeuralNetHopf1.Layers[1].Neurons[z].Output := 1
    else
      NeuralNetHopf1.Layers[1].Neurons[z].Output := -1;
  end;

// Запуск процесса распознования
NeuralNetHopf1.Calc;

// получаем результат
for i := 0 to Length(zInputVector) - 1 do
 if NeuralNetHopf1.Layers[1].Neurons[i].Output = -1 then
   Memo.Lines.Add(FloatToStr(0))
 else
   Memo.Lines.Add(FloatToStr(1));

// устанавливаем размер вектора входа для сети обратного распространения
SetLength(xInputVector, NeuralNetExtended1.InputFieldCount);

// считаем, сколько у нас букв в слове (выпендрился)
simbols:= NeuralNetHopf1.Layers[1].NeuronCount / NeuralNetExtended1.InputNeuronCount;

// счетчик строк
h:= 0;
// Вывод результата
for z := 0 to StrToInt(FloatToStr(simbols)) - 1 do
  begin
    // заполняем вектор входа кодом буквы
    for I := 0 to 5 do
      begin
        xInputVector[i] := StrToInt(Memo.Lines[h]);
        inc(h);
      end;
    // Просчитываем
    NeuralNetExtended1.ComputeUnPrepData(xInputVector);
    // Выводим результат
    res:= FloatToStr(NeuralNetExtended1.Output[0]);

    // округляем полученный код буквы
    if (res[6] = '8') or (res[6] = '9') or (res[6] = '7') or (res[6] = '6')then
      res:= IntToStr(StrToInt(copy(res, 1, 4)) + 1)
    else
      res:= copy(res, 1, 4);

    // выводим букву в мемо
    Memo.Lines.Add(chr(strtoint(res)));
  end;
    

Ответы

Ответ 1

А какого типа у вас zInputVector? Если это класс или массив, то это является указателем,
т.е. во время первого цикла, где добавляется пример для выборки при изменении значения
 zInputVector[f], меняются также значения тех, что уже добавлены.

Попробуйте после

  f:= 0; // обнуляем элемент вектора
  // Пробегаем каждую букву в слове


Выделить новую память для zInputVector. Если класс, то zInputVector:=Classname.Create,
если другое то New, или getMem, смотря по ситуации.

Вроде так. Но не уверен, с нейро сетью Хопфилда не приходилось общяться.

Какие нейросети выбрать под данные типы задач?

#нейронные_сети #искусственный_интеллект

Пытаюсь как-то уложить все в голове, интересует какие сети лучше подойдут для задач
и почему

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

Допустим, задачи такие:


Распознавание голоса
Обучение музыкальному вкусу и поиск похожих песен
Контроль температуры инерционной системы (нужно очень быстрое обучение прям в процессе,
иначе что-то может перегреется или переохладится)
Распознавание графиков (допустим, спектра)
Научить узнавать человека с камеры по одному его фото

    

Ответы

Ответ 1

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

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

RNN Рекурентная нейронная сеть - сеть которая делает вывод основываясь не только
на настоящих данных но и на прошедших. Используется там где важно учитивать влияние
нескольких факторов.

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

CNN Сверточная нейронная сеть - НС которая обрабатывает данные с помощью фильтров
и сети прямого распространения.

Отвечая на Ваш вопрос:

1 и 2 - LSTM. Все что связанно с обработкой речи и анализом текста нуждается в контексте,
также по умолчанию предложение это последовательная расстановка слов которые связанны
друг с другом по смыслу.

3 - FFNN. Не совсем понял суть но если логика заключается в том чтобы в заисимости
от набора факторов выставлять температуру то сеть прямого распространения подойдет
лучше всего.

4 - Либо FFNN либо RNN в зависимости от сложности и "предсказуемости" графика.

5 - CNN. Все что связанно с распознавание обьектов и анализом фото или видео, всегда
используется сверточная нейронная сеть.

Как подать массив данных 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)

Какой тип нейронной сети нужно выбрать для решения задачи?

#нейронные_сети

У меня имеется набор изображений с коррозионными дефектами, на основе которых я хочу
научить НС обводить дефекты контурами.

На вход дается левое изображение, на выходе - правое.



Какой тип нейронной сети мне следует выбрать для решения этой задачи?

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

Ответы

Ответ 1

Попробуйте использовать Semantic Segmentation CNN:



PS вам придется обучить НС на ваших данных

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

#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 (вычисленного в шаге обучения) обратно на все нейроны, чьи выходные
сигналы были входящими для последнего нейрона. Собственно, поэтому алгоритм так и называется.

Нейронная сеть

#нейронные_сети

Может быть кто-нибудь знает хороший источник с информацией на эту тему?
(желательнее чтобы информация была попроще и с примерами)    

Ответы

Ответ 1

Нейронные сети (statsoft)
Нейронные сети (basegroup)
Введение в теорию (каталог ресурсов)


Ответ 2

вот здесь есть подборка достаточно свежих статей с практическим применением. А вам
какие примеры нужно? Типа участков кода? или описание практических алгоритмов?

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

#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']

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

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

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

Ответы

Ответ 1

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

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

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

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

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

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


Ответ 2

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


Ответ 3

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

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

Источник


Ответ 4

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