IPB

–Ъ–ї—Г–± –Ш–љ–≤–µ—Б—В–Њ—А–Њ–≤ FXTDE.Pro - –Ш–љ–≤–µ—Б—В–Є—А—Г–є—В–µ —Б —Г–Љ–Њ–Љ

«дравствуйте, гость ( ¬ход | –егистраци€ )

8 страниц V   1 2 3 > »   
ќтветить в данную темуЌачать новую тему
> Ќейронные сети
Admin
сообщение 19.8.2008, 14:18
—ообщение #1


јлхимик
»конка группы

√руппа: √лавные јдминистраторы
—ообщений: 5976
–епутаци€: 13
–егистраци€: 5.8.2008
»з: »спани€
ѕользователь є: 1
—пасибо сказали: 4610 раз(а)





»скусственные Ќейронные —ети
(»Ќ—)



1.  ак работает биологическа€ нейронна€ сеть

Ќервна€ система и мозг человека состо€т из нейронов, соединенных между собой нервными волокнами. Ќервные волокна способны передавать электрические импульсы между нейронами. ¬се процессы передачи раздражений от нашей кожи, ушей и глаз к мозгу, процессы мышлени€ и управлени€ действи€ми - все это реализовано в живом организме как передача электрических импульсов между нейронами. –ассмотрим строение биологического нейрона.  аждый нейрон имеет отростки нервных волокон двух типов - дендриты, по которым принимаютс€ импульсы, и единственный аксон, по которому нейрон может передавать импульс. јксон контактирует с дендритами других нейронов через специальные образовани€ - синапсы, которые вли€ют на силу импульса.



ћожно считать, что при прохождении синапса сила импульса мен€етс€ в определенное число раз, которое мы будем называть весом синапса. »мпульсы, поступившие к нейрону одновременно по нескольким дендритам, суммируютс€. ≈сли суммарный импульс превышает некоторый порог, нейрон возбуждаетс€, формирует собственный импульс и передает его далее по аксону. ¬ажно отметить, что веса синапсов могут измен€тьс€ со временем, а значит, мен€етс€ и поведение соответствующего нейрона.

Ќетрудно построить математическую модель описанного процесса.



Ќа рисунке изображена модель нейрона с трем€ входами (дендритами), причем синапсы этих дендритов имеют веса w1, w2, w3. ѕусть к синапсам поступают импульсы силы x1, x2, x3 соответственно, тогда после прохождени€ синапсов и дендритов к нейрону поступают импульсы w1x1, w2x2, w3x3. Ќейрон преобразует полученный суммарный импульс x=w1x1+ w2x2+ w3x3 в соответствии с некоторой передаточной функцией f(x). —ила выходного импульса равна y=f(x)=f(w1x1+ w2x2+ w3x3).
“аким образом, нейрон полностью описываетс€ своими весами wk и передаточной функцией f(x). ѕолучив набор чисел (вектор) xk в качестве входов, нейрон выдает некоторое число y на выходе.

2. „то такое искусственна€ нейронна€ сеть

 ак работает нейронна€ сеть

»скусственна€ нейронна€ сеть (»Ќ—, нейронна€ сеть) - это набор нейронов, соединенных между собой.  ак правило, передаточные функции всех нейронов в нейронной сети фиксированы, а веса €вл€ютс€ параметрами нейронной сети и могут измен€тьс€. Ќекоторые входы нейронов помечены как внешние входы нейронной сети, а некоторые выходы - как внешние выходы нейронной сети. ѕодава€ любые числа на входы нейронной сети, мы получаем какой-то набор чисел на выходах нейронной сети. “аким образом, работа нейронной сети состоит в преобразовании входного вектора в выходной вектор, причем это преобразование задаетс€ весами нейронной сети.

ѕрактически любую задачу можно свести к задаче, решаемой нейронной сетью. ¬ этой таблице показано, каким образом следует сформулировать в терминах нейронной сети задачу распознавани€ рукописных букв.

«адача распознавани€ рукописных букв

ƒано: растровое черно-белое изображение буквы размером 30x30 пикселов
Ќадо: определить, кака€ это буква (в алфавите 33 буквы)

‘ормулировка дл€ нейронной сети:

ƒано: входной вектор из 900 двоичных символов (900=30x30)
Ќадо: построить нейронную сеть с 900 входами и 33 выходами, которые помечены буквами. ≈сли на входе нейронной сети изображение буквы "ј", то максимальное значение выходного сигнала достигаетс€ на выходе "ј". јналогично нейронна€ сеть работает дл€ всех 33 букв.

ѕо€сним, зачем требуетс€ выбирать выход нейронной сети с максимальным уровнем сигнала. ƒело в том, что уровень выходного сигнала, как правило, может принимать любые значени€ из какого-то отрезка. ќднако, в данной задаче нас интересует не аналоговый ответ, а всего лишь номер категории (номер буквы в алфавите). ѕоэтому используетс€ следующий подход - каждой категории сопоставл€етс€ свой выход, а ответом нейронной сети считаетс€ та категори€, на чьем выходе уровень сигнала максимален. ¬ определенном смысле уровень сигнала на выходе "ј" - это достоверность того, что на вход нейронной сети была подана рукописна€ буква "A". «адачи, в которых нужно отнести входные данные к одной из известных категорий, называютс€ задачами классификации. »зложенный подход - стандартный способ классификации с помощью нейронных сетей.

 ак постороить нейронную сеть

“еперь, когда стало €сно, что именно мы хотим построить, мы можем переходить к вопросу "как строить такую нейронную сеть". Ётот вопрос решаетс€ в два этапа:

  1. ¬ыбор типа (архитектуры) нейронной сети.
  2. ѕодбор весов (обучение) нейронной сети.


Ќа первом этапе следует выбрать следующее:

  • какие нейроны мы хотим использовать (число входов, передаточные функции);
  • каким образом следует соединить их между собой;
  • что вз€ть в качестве входов и выходов нейронной сети.


Ёта задача на первый взгл€д кажетс€ необозримой, но, к счастью, нам необ€зательно придумывать нейронную сеть "с нул€" - существует несколько дес€тков различных нейросетевых архитектур, причем эффективность многих из них доказана математически. Ќаиболее попул€рные и изученные архитектуры - это многослойный перцептрон, нейронна€ сеть с общей регрессией, нейронные сети  охонена и другие. ѕро все эти архитектуры скоро можно будет прочитать в специальном разделе этого учебника.

Ќа втором этапе нам следует "обучить" выбранную нейронную сеть, то есть подобрать такие значени€ ее весов, чтобы она работала нужным образом. Ќеобученна€ нейронна€ сеть подобна ребенку - ее можно научить чему угодно. ¬ используемых на практике нейронных сет€х количество весов может составл€ть несколько дес€тков тыс€ч, поэтому обучение - действительно сложный процесс. ƒл€ многих архитектур разработаны специальные алгоритмы обучени€, которые позвол€ют настроить веса нейронной сети определенным образом. Ќаиболее попул€рный из этих алгоритмов - метод обратного распространени€ ошибки (Error Back Propagation), используемый, например, дл€ обучени€ перцептрона.

ќбучение нейронных сетей

ќбучить нейронную сеть - значит, сообщить ей, чего мы от нее добиваемс€. Ётот процесс очень похож на обучение ребенка алфавиту. ѕоказав ребенку изображение буквы "ј", мы спрашиваем его: " ака€ это буква?" ≈сли ответ неверен, мы сообщаем ребенку тот ответ, который мы хотели бы от него получить: "Ёто буква ј". –ебенок запоминает этот пример вместе с верным ответом, то есть в его пам€ти происход€т некоторые изменени€ в нужном направлении. ћы будем повтор€ть процесс предъ€влени€ букв снова и снова до тех пор, когда все 33 буквы будут твердо запомнены. “акой процесс называют "обучение с учителем".



ѕри обучении нейронной сети мы действуем совершенно аналогично. ” нас имеетс€ некотора€ база данных, содержаща€ примеры (набор рукописных изображений букв). ѕредъ€вл€€ изображение буквы "ј" на вход нейронной сети, мы получаем от нее некоторый ответ, не об€зательно верный. Ќам известен и верный (желаемый) ответ - в данном случае нам хотелось бы, чтобы на выходе нейронной сети с меткой "ј" уровень сигнала был максимален. ќбычно в качестве желаемого выхода в задаче классификации берут набор (1, 0, 0, ...), где 1 стоит на выходе с меткой "ј", а 0 - на всех остальных выходах. ¬ычисл€€ разность между желаемым ответом и реальным ответом сети, мы получаем 33 числа - вектор ошибки. јлгоритм обратного распространени€ ошибки - это набор формул, который позвол€ет по вектору ошибки вычислить требуемые поправки дл€ весов нейронной сети. ќдну и ту же букву (а также различные изображени€ одной и той же буквы) мы можем предъ€вл€ть нейронной сети много раз. ¬ этом смысле обучение скорее напоминает повторение упражнений в спорте - тренировку.

ќказываетс€, что после многократного предъ€влени€ примеров веса нейронной сети стабилизируютс€, причем нейронна€ сеть дает правильные ответы на все (или почти все) примеры из базы данных. ¬ таком случае говор€т, что "нейронна€ сеть выучила все примеры", "нейронна€ сеть обучена", или "нейронна€ сеть натренирована". ¬ программных реализаци€х можно видеть, что в процессе обучени€ величина ошибки (сумма квадратов ошибок по всем выходам) постепенно уменьшаетс€.  огда величина ошибки достигает нул€ или приемлемого малого уровн€, тренировку останавливают, а полученную нейронную сеть считают натренированной и готовой к применению на новых данных.

¬ажно отметить, что вс€ информаци€, которую нейронна€ сеть имеет о задаче, содержитс€ в наборе примеров. ѕоэтому качество обучени€ нейронной сети напр€мую зависит от количества примеров в обучающей выборке, а также от того, насколько полно эти примеры описывают данную задачу. “ак, например, бессмысленно использовать нейронную сеть дл€ предсказани€ финансового кризиса, если в обучающей выборке кризисов не представлено. —читаетс€, что дл€ полноценной тренировки нейронной сети требуетс€ хот€ бы несколько дес€тков (а лучше сотен) примеров.
ѕовторим еще раз, что обучение нейронных сетей - сложный и наукоемкий процесс. јлгоритмы обучени€ нейронных сетей имеют различные параметры и настройки, дл€ управлени€ которыми требуетс€ понимание их вли€ни€.

ѕрименение нейронной сети



ѕосле того, как нейронна€ сеть обучена, мы можем примен€ть ее дл€ решени€ полезных задач. ¬ажнейша€ особенность человеческого мозга состоит в том, что, однажды обучившись определенному процессу, он может верно действовать и в тех ситуаци€х, в которых он не бывал в процессе обучени€. Ќапример, мы можем читать почти любой почерк, даже если видим его первый раз в жизни. “ак же и нейронна€ сеть, грамотным образом обученна€, может с большой веро€тностью правильно реагировать на новые, не предъ€вленные ей ранее данные. Ќапример, мы можем нарисовать букву "ј" другим почерком, а затем предложить нашей нейронной сети классифицировать новое изображение. ¬еса обученной нейронной сети хран€т достаточно много информации о сходстве и различи€х букв, поэтому можно рассчитывать на правильный ответ и дл€ нового варианта изображени€.

ѕримеры готовых нейронных сетей

ќписанные выше процессы обучени€ и применени€ нейронных сетей можно увидеть в действии пр€мо сейчас. ‘ирмой Ward Systems Group подготовлено несколько простых программ, которые написаны на основе библиотеки NeuroWindows.  ажда€ из программ позвол€ет пользователю самосто€тельно задать набор примеров и обучить на этом наборе определенную нейронную сеть. «атем можно предлагать этой нейронной сети новые примеры и наблюдать ее работу.

3. ќбласти применени€ нейронных сетей

Ќейросетева€ классификаци€

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



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



 лассификаци€ предпри€тий по степени их перспективности - это уже привычный способ использовани€ нейронных сетей в практике западных компаний. ѕри этом нейронна€ сеть также использует множество экономических показателей, сложным образом св€занных между собой.

Ќейросетевой подход особенно эффективен в задачах экспертной оценки по той причине, что он сочетает в себе способность компьютера к обработке чисел и способность мозга к обобщению и распознаванию. √овор€т, что у хорошего врача способность к распознаванию в своей области столь велика, что он может провести приблизительную диагностику уже по внешнему виду пациента. ћожно согласитьс€ также, что опытный трейдер чувствует направление движени€ рынка по виду графика. ќднако в первом случае все факторы нагл€дны, то есть характеристики пациента мгновенно воспринимаютс€ мозгом как "бледное лицо", "блеск в глазах" и т.д. ¬о втором же случае учитываетс€ только один фактор, показанный на графике - курс за определенный период времени. Ќейронна€ сеть позвол€ет обрабатывать огромное количество факторов (до нескольких тыс€ч), независимо от их нагл€дности - это универсальный "хороший врач", который может поставить свой диагноз в любой области.

 ластеризаци€ с помощью нейронных сетей и поиск зависимостей

ѕомимо задач классификации, нейронные сети широко используютс€ дл€ поиска зависимостей в данных и кластеризации.



Ќапример, нейронна€ сеть на основе методики ћ√”ј (метод группового учета аргументов) позвол€ет на основе обучающей выборки построить зависимость одного параметра от других в виде полинома. “ака€ нейронна€ сеть может не только мгновенно выучить таблицу умножени€, но и найти сложные скрытые зависимости в данных (например, финансовых), которые не обнаруживаютс€ стандартными статистическими методами.



 ластеризаци€ - это разбиение набора примеров на несколько компактных областей (кластеров), причем число кластеров заранее неизвестно.  ластеризаци€ позвол€ет представить неоднородные данные в более нагл€дном виде и использовать далее дл€ исследовани€ каждого кластера различные методы. Ќапример, таким образом можно быстро вы€вить фальсифицированные страховые случаи или недобросовестные предпри€ти€.

ѕрименение нейронных сетей в задачах прогнозировани€

«адачи прогнозировани€ особенно важны дл€ практики, в частности, дл€ финансовых приложений, поэтому по€сним способы применени€ нейронных сетей в этой области более подробно.

–ассмотрим практическую задачу, ответ в которой неочевиден - задачу прогнозировани€ курса акций на 1 день вперед.
ѕусть у нас имеетс€ база данных, содержаща€ значени€ курса за последние 300 дней. ѕростейший вариант в данном случае - попытатьс€ построить прогноз завтрашней цены на основе курсов за последние несколько дней. ѕон€тно, что прогнозирующа€ нейронна€ сеть должна иметь всего один выход и столько входов, сколько предыдущих значений мы хотим использовать дл€ прогноза - например, 4 последних значени€. —оставить обучающий пример очень просто - входными значени€ми нейронной сети будут курсы за 4 последовательных дн€, а желаемым выходом нейронной сети - известный нам курс в следующий день за этими четырьм€.

≈сли нейронна€ сеть совместима с какой-либо системой обработки электронных таблиц (например, Excel), то подготовка обучающей выборки состоит из следующих операций:

  1. —копировать столбец данных значений котировок в 4 соседних столбца.
  2. —двинуть второй столбец на 1 €чейку вверх, третий столбец - на 2 €чейки вверх и т.д.




—мысл этой подготовки легко увидеть на рисунке - теперь кажда€ строка таблицы представл€ет собой обучающий пример, где первые 4 числа - входные значени€ нейронные сети, а п€тое число - желаемое значение выхода нейронной сети. »сключение составл€ют последние 4 строки, где данных недостаточно - эти строки не учитываютс€ при тренировке нейронной сети. «аметим, что в четвертой снизу строке заданы все 4 входных значени€, но неизвестно значение выхода нейронной сети. »менно к этой строке мы применим обученную нейронную сеть и получим прогноз на следующий день.

 ак видно из этого примера, объем обучающей выборки зависит от выбранного нами количества входов нейронной сети. ≈сли сделать 299 входов, то така€ нейронна€ сеть потенциально могла бы строить лучший прогноз, чем нейронна€ сеть с 4 входами, однако в этом случае мы имеем всего 1 обучающий пример, и обучение бессмысленно. ѕри выборе числа входов нейронной сети следует учитывать это, выбира€ разумный компромисс между глубиной предсказани€ (число входов нейронной сети) и качеством обучени€ нейронной сети (объем тренировочного набора).

ѕервоисточник - NeuroProject: http://www.neuroproject.ru/neuro.htm


--------------------
Ќикто не может вернутьс€ назад, начать все с начала и изменить прошлое, но любой может начать сейчас и изменить будущее.
ѕерейти в начало страницы
 
+÷итировать сообщение
Admin
сообщение 24.9.2008, 19:29
—ообщение #2


јлхимик
»конка группы

√руппа: √лавные јдминистраторы
—ообщений: 5976
–епутаци€: 13
–егистраци€: 5.8.2008
»з: »спани€
ѕользователь є: 1
—пасибо сказали: 4610 раз(а)




¬ажно помнить, что нейросети Ќ≈ ѕјЌј÷≈я. Ёто просто »ЌC“–”ћ≈Ќ“. » есть куча нейросетевых программ - черных €щиков.
 оторые говор€т - что покупать, а что продавать, и по сути мало чего общего имеют с нейросет€ми, да и не дают покопатьс€ внутри (всмысле настроить нейросеть). “акой отстой можно сразу отметать.

—амую эффективную сеть, которую € видел, действительно была написана человеком под себ€.
’орошие нейросетевые программные комплексы сто€т дорого... еще дороже јѕѕј–ј“”–ј (нейросетевые вычислители).

Ќе надо думать, что вы возьмете сеть, скажете чего предсказывать и она начнет творить чудеса..
—еть способна найти зависимости, но найти там, где они ≈—“№. —верхестественных вещей они вам не сделают.
—оответственно став€ изначально перед сетью не реальные задачи, результата не будет.
“аким образом, если пытатьс€ предсказать уровень преступности на основе цвета носков Ѕуша, мы не получим адекватного результата.
ќднако, если посмотреть зависимость от темпов инфл€ции, безработицы в стране, уровн€ зарплаты и т.д., то думаю можно сделать прогноз.

“ак что обучить сеть правильно, это целое искусство, мало того, надо еще обучать правильную сеть, т.е. выбрать нужную внутреннюю архитектуру и т.д. » разработать нейросеть дл€ прогнозов - задача не мене сложна€, чем построить более менее прибыльную “— на индикаторах.

ѕрограммные пакеты дл€ разработки нейросетей сто€т хороших денег, большинство из них продаютс€ с адаптерами, которые сто€т на пор€дки дороже самого ѕќ, и это всего лишь инструмент, а не волшебна€ палочка.... т.е. просто купив ѕќ и "потыркав" в нем мышкой, оно чудесным образом торговать прибыльно не станет. ѕотому ѕќ и продаетс€, потому оно дорогое, и потому на нем так же не заработает большинство.


--------------------
Ќикто не может вернутьс€ назад, начать все с начала и изменить прошлое, но любой может начать сейчас и изменить будущее.
ѕерейти в начало страницы
 
+÷итировать сообщение
Admin
сообщение 25.9.2008, 19:20
—ообщение #3


јлхимик
»конка группы

√руппа: √лавные јдминистраторы
—ообщений: 5976
–епутаци€: 13
–егистраци€: 5.8.2008
»з: »спани€
ѕользователь є: 1
—пасибо сказали: 4610 раз(а)




»з аппаратуры много чего можно перечислить, тот же старый добрый CNAPS/PC 128 - разработка от Adaptive Solution
или BrainMaker Pro CNAPS Accelerator Board от California Scientific Software
или APx - Array Processor Accelerator, GENES~IV, NeuroMatrixЃ M÷ - отечественна€ разработка, делает Ќ“÷ "ћодуль".

вот так он примерно выгл€дит:


или поколение Synaps. (1,2, и 3) ѕикова€ эффективность одной нейроплаты Synaps3 - 2.4 млрд.операций/сек.
CNAPS/PC-128 имеет пиковое быстродействие 2,27млрд.соединений/сек
≈сть более известные разработки от IBM, например ZISC 036

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

≈сть уже готовые нейрокомпьютеры -
AAP-2 , ANNA , Analog Neural Computer, ASP -- Associative String Processor , BSP400 , BLAST , CNAPS Neurocomputer, Mindshape , mod 2 , NERV, RENNS,
SMART, SYNAPSE-1 и т.д.

¬месте с адаптером можно приобрести пакет Brain Maker
 оторый активно использовалс€ в биржевой торговле на фондовых рынках нашими же российскими банками!


--------------------
Ќикто не может вернутьс€ назад, начать все с начала и изменить прошлое, но любой может начать сейчас и изменить будущее.
ѕерейти в начало страницы
 
+÷итировать сообщение
Admin
сообщение 17.10.2008, 23:21
—ообщение #4


јлхимик
»конка группы

√руппа: √лавные јдминистраторы
—ообщений: 5976
–епутаци€: 13
–егистраци€: 5.8.2008
»з: »спани€
ѕользователь є: 1
—пасибо сказали: 4610 раз(а)




ѕример индикатора дл€ Equis MetaStock на основе однослойного перцептрона на 5ти нейронах.
Perceptron 5 by FXTDE © 2008


ѕрикрепленные файлы
ѕрикрепленный файл  perceptron.zip ( 2,9 килобайт )  ол-во скачиваний: 110
 


--------------------
Ќикто не может вернутьс€ назад, начать все с начала и изменить прошлое, но любой может начать сейчас и изменить будущее.
ѕерейти в начало страницы
 
+÷итировать сообщение
Admin
сообщение 4.8.2009, 19:26
—ообщение #5


јлхимик
»конка группы

√руппа: √лавные јдминистраторы
—ообщений: 5976
–епутаци€: 13
–егистраци€: 5.8.2008
»з: »спани€
ѕользователь є: 1
—пасибо сказали: 4610 раз(а)




ѕодготовка данных:

ƒл€ начала нам необходимо подготовить данные дл€ обработки

«апускаем Equis Metastock и нажимаем CTRL-D

ѕосле запуска The Downloader нажимаем CTRL-O

¬ыбираем Security. Ќапример, USDCHF



» жмем Open



¬ открывшемс€ окне выдел€ем все данные, копируем (Ctrl-C) и вставл€ем в Microsoft Excel (Ctrl-V)



--------------------
Ќикто не может вернутьс€ назад, начать все с начала и изменить прошлое, но любой может начать сейчас и изменить будущее.
ѕерейти в начало страницы
 
+÷итировать сообщение
Admin
сообщение 4.8.2009, 23:20
—ообщение #6


јлхимик
»конка группы

√руппа: √лавные јдминистраторы
—ообщений: 5976
–епутаци€: 13
–егистраци€: 5.8.2008
»з: »спани€
ѕользователь є: 1
—пасибо сказали: 4610 раз(а)




ѕоскольку индикаторы €вл€ютс€ производными цены, при подаче на вход значени€ индикаторов, мы получим систему - Укуча мусора на входе Ц куча мусора на выходеФ.

—ама по себе цена закрыти€ €вл€етс€ субъективным показателем, т.к. €вл€етс€ выборкой из потока цен. —веча несет недостаточно данных, т.к. мы не знаем хронологию формировани€ Hi и Low, но т.к. мы не работаем с тиковым потоком котировок, мы будем делать анализ на основе расчетного показател€ с учетом всех данных свечи.

¬ качестве такого показател€ мной был выбран расчет точки вращени€ (Pivot Point).
»менно направление движени€ графика построенного по точкам вращени€ мы будем анализировать, прогнозировать его поведение и дальнейшее движение рынка.

–ассчитаем Pivot Point, добавив формулу в нашу таблицу:

P = (H + L + C) / 3



¬ качестве анализируемого периода возьмем недельный интервал (т.е. последние 5 рабочих дней), соответственно добавим четыре столбца со значени€ми Pivot со смещением 1 день.



» так, мы получили данные дл€ дальнейшего анализа. ќднако абсолютные значени€ не пригодны дл€ обучени€ нейронной сети, поэтому наши данные надо нормализоватьЕ


--------------------
Ќикто не может вернутьс€ назад, начать все с начала и изменить прошлое, но любой может начать сейчас и изменить будущее.
ѕерейти в начало страницы
 
+÷итировать сообщение
Admin
сообщение 5.8.2009, 0:59
—ообщение #7


јлхимик
»конка группы

√руппа: √лавные јдминистраторы
—ообщений: 5976
–епутаци€: 13
–егистраци€: 5.8.2008
»з: »спани€
ѕользователь є: 1
—пасибо сказали: 4610 раз(а)




¬ качестве входов и выходов нейронной сети не следует использовать абсолютные значени€ цен и их производных. «начимыми дл€ прогнозировани€ €вл€ютс€ изменени€ цен Ц приращени€.

–ассчитаем изменение значение Pivot Point в процентах.

≈сли прошлое значение Pivot Point меньше насто€щего(значение увеличилось), то процент изменени€ равен: 1 минус отношение прошлого значени€ к насто€щему, умноженное на 100%

≈сли прошлое значение Pivot Point больше насто€щего (значение уменьшилось), то процент изменени€ равен: отношение насто€щего значени€ к прошлому, минус 1 и умноженное на 100%

‘ормула дл€ Microsoft Excel будет выгл€деть следующим образом:

=≈—Ћ»(F2<F3;(1-(F2/F3))*100;((F3/F2)-1)*100)

√де F2 Ц прошлое значение Pivot Point, а F3 Ц текущее значение Pivot Point

ƒобавим наши расчеты в таблицу:



ѕо аналогии, как мы сделали с абсолютными значени€ми Pivot Point,в качестве анализируемого периода возьмем недельный интервал (т.е. последние 5 рабочих дней), соответственно добавим четыре столбца со значени€ми %Pivot со смещением 1 день.



»так, мы привели входные данные в соответствующий вид. Ќо дл€ создани€ обучающей выборки, кроме входного вектора, нам необходимо создать выходной вектор. “.е. то, чему мы будем учить нашу сеть.


--------------------
Ќикто не может вернутьс€ назад, начать все с начала и изменить прошлое, но любой может начать сейчас и изменить будущее.
ѕерейти в начало страницы
 
+÷итировать сообщение
Admin
сообщение 5.8.2009, 10:50
—ообщение #8


јлхимик
»конка группы

√руппа: √лавные јдминистраторы
—ообщений: 5976
–епутаци€: 13
–егистраци€: 5.8.2008
»з: »спани€
ѕользователь є: 1
—пасибо сказали: 4610 раз(а)




Ќашей задачей €вл€етс€ не предсказание точного курса цены в будущем, а прогнозирование направлени€ движени€ рынка. ”меньшение значений Pivot Point характеризуетс€ отрицательным показателем процента изменени€, а увеличение Ц положительным. ќднако, т.к. входной вектор представл€ет собой именно процент изменений показателей Pivot Point, то и в выходном векторе мы будем использовать процент изменений, на спрогнозированных значени€х которого уже будем судить о том, верно ли определено дальнейшее движение рынка или нет.

ѕодобно тому, как мы смещали показани€ Pivot Point вперед дл€ того, чтобы использовать при анализе прошлые значени€ его изменений, теперь мы сместим значени€ на один шаг назад, чтобы при обучении использовать данные о том, какие показатели будут в будущем , т.к. именно эти значени€ нам необходимо прогнозировать с точностью до знака (больше или меньше нол€).



”далим непригодные дл€ обработки данные в начале выборки (выделено красным):



ќбрежем неиспользуемые данные в конце выборки (выделено красным):



”далим лишние столбцы и сохраним документ, как CSV файл (разделители У;Ф)

ѕрикрепленный файл  io.zip ( 28,91 килобайт )  ол-во скачиваний: 47


ќбучающа€ выборка готова. “еперь у нас есть все данные дл€ обучени€ нейронной сети.


--------------------
Ќикто не может вернутьс€ назад, начать все с начала и изменить прошлое, но любой может начать сейчас и изменить будущее.


—пасибо сказали:
kvn,
ѕерейти в начало страницы
 
+÷итировать сообщение
Admin
сообщение 5.8.2009, 22:30
—ообщение #9


јлхимик
»конка группы

√руппа: √лавные јдминистраторы
—ообщений: 5976
–епутаци€: 13
–егистраци€: 5.8.2008
»з: »спани€
ѕользователь є: 1
—пасибо сказали: 4610 раз(а)




—оздадим сети следющих архитектур в формате NSB

Multilayer Perceptron



Input PEs: 5
Output PEs: 1
Exemplars: 5346

Hidden Layers: 1

—качать: ѕрикрепленный файл  Multilayer_Perceptron.zip ( 16,07 килобайт )  ол-во скачиваний: 55



Generalized Feed Forward



Input PEs: 5
Output PEs: 1
Exemplars: 5346

Hidden Layers: 1

—качать: ѕрикрепленный файл  Generalized_Feed_Forward.zip ( 18,1 килобайт )  ол-во скачиваний: 25



Modular Neural Network



Input PEs: 5
Output PEs: 1
Exemplars: 5346

Hidden Layers: 2

—качать: ѕрикрепленный файл  Modular_Neural_Network.zip ( 41,53 килобайт )  ол-во скачиваний: 25



Jordan/Elman Network



Input PEs: 5
Output PEs: 1
Exemplars: 5346

Hidden Layers: 1

ContextUnits: IntegratorAxon
Time: 0.8

—качать: ѕрикрепленный файл  Jordan_Elman_Network.zip ( 24,34 килобайт )  ол-во скачиваний: 21



Principal Component Analysis (PCA)



Input PEs: 5
Output PEs: 1
Exemplars: 5346

Hidden Layers: 1

Principal Components: 4
GA: No

Learning Rule: SangersFull

—качать: ѕрикрепленный файл  Principal_Component_Analysis__PCA_.zip ( 18,01 килобайт )  ол-во скачиваний: 24



RBF/GRNN/PNN Network



Input PEs: 5
Output PEs: 1
Exemplars: 5346

Hidden Layers: 0

Regression/Probabilistic: No

Cluster Centers: 25
GA: No

Competitive Rule: ConscienceFull

Metric: Euclidean

—качать: ѕрикрепленный файл  RBF_GRNN_PNN_Network.zip ( 11,98 килобайт )  ол-во скачиваний: 28



Self-Organizing Feature Map Network



Input PEs: 5
Output PEs: 1
Exemplars: 5346

Hidden Layers: 1

Rows: 5

Columns: 5

Starting Radius: 2

Final Radius: 0

Neighborhood Shape: SquareKohonenFull

—качать: ѕрикрепленный файл  Self_Organizing_Feature_Map_Network.zip ( 38,25 килобайт )  ол-во скачиваний: 30



Time-Lag Recurrent Network



Input PEs: 5
Output PEs: 1
Exemplars: 5346

Hidden Layers: 1

Memory: Focused; GammaAxon
Depth in samples: 10

Trajectory Length: 50

—качать: ѕрикрепленный файл  Time_Lag_Recurrent_Network.zip ( 17,38 килобайт )  ол-во скачиваний: 26



Recurrent Network



Input PEs: 5
Output PEs: 1
Exemplars: 5346

Hidden Layers: 1

Input Layer: Axon

Recurrency: Partially Recurrent

—качать: ѕрикрепленный файл  Recurrent_Network.zip ( 10,84 килобайт )  ол-во скачиваний: 25



CANFIS Network (Fuzzy Logic)



Input PEs: 5
Output PEs: 1
Exemplars: 5346

Membership Function: Bell
MFs per Input: 3

Fuzzy Model: TSK

—качать: ѕрикрепленный файл  CANFIS_Network__Fuzzy_Logic_.zip ( 45,36 килобайт )  ол-во скачиваний: 26


--------------------
Ќикто не может вернутьс€ назад, начать все с начала и изменить прошлое, но любой может начать сейчас и изменить будущее.
ѕерейти в начало страницы
 
+÷итировать сообщение
Admin
сообщение 5.8.2009, 22:31
—ообщение #10


јлхимик
»конка группы

√руппа: √лавные јдминистраторы
—ообщений: 5976
–епутаци€: 13
–егистраци€: 5.8.2008
»з: »спани€
ѕользователь є: 1
—пасибо сказали: 4610 раз(а)




Support Vector Machine



Input PEs: 5
Output PEs: 1
Exemplars: 5346


—качать:

ѕрикрепленные файлы
ѕрикрепленный файл  Support_Vector_Machine.zip ( 119,44 килобайт )  ол-во скачиваний: 40
 


--------------------
Ќикто не может вернутьс€ назад, начать все с начала и изменить прошлое, но любой может начать сейчас и изменить будущее.
ѕерейти в начало страницы
 
+÷итировать сообщение
Admin
сообщение 7.8.2009, 13:18
—ообщение #11


јлхимик
»конка группы

√руппа: √лавные јдминистраторы
—ообщений: 5976
–епутаци€: 13
–егистраци€: 5.8.2008
»з: »спани€
ѕользователь є: 1
—пасибо сказали: 4610 раз(а)




ƒл€ дальнейшего анализа с помощью нейронных сетей воспользуемс€ надстройкой дл€ Microsoft Excel : NSForExcel5.xla

ќткрываем нашу обучающую выборку.

¬ разделе УЌадстройка: Preprocess Data -> DifferenceФ мы можем рассчитать относительные изменени€ параметров.
Ќо дл€ общего понимани€ мы это уже сделали вручную и входной вектор уже представлен в виде изменений, а не абсолютных величин.
ѕоэтому мы можем пропустить пункты Preprocess Data и Analyze Data.

¬ыдел€ем первые п€ть столбцов и помечаем их как Input. (Ќадстройка: Tag Data -> Column(s) As Input)

¬ыдел€ем шестой столбец и помечаем их как Desired. (Ќадстройка: Tag Data -> Column(s) As Desired)

¬ нашей выборке мы имеем 2678 строк с данными:

60% отведем на тренировку сети. (~1606)
20% на кросс-тест. (~536)
» оставшиес€ 20% на тестирование сети. (~536)

¬ыдел€ем первые 1606 строк и помечаем как Training. (Ќадстройка: Tag Data -> Row(s) As Training)

¬ыдел€ем последующие 536 строк и помечаем как Cross Validation. (Ќадстройка: Tag Data -> Row(s) As Cross Validation)

¬ыдел€ем оставшиес€ 536 строк и помечаем как Testing. (Ќадстройка: Tag Data -> Row(s) As Testing)



ќткрываем одну из наших сетей, либо создаем новую. (Ќадстройка: Create/Open Network -> Е )

ƒалее мы можем создать файлы данных. (Ќадстройка: Create Data Files ->All Files)

» переходим к обучению нашей сети. (Ќадстройка: Train Network -> TrainЕ)


( оличество Ёпох - 1000)

дожидаемс€ окончани€ обучени€



ѕосле окончани€ обучени€ будут созданы два листа: Train Report и Train MSE

MSE Ц —редн€€ квадратична€ ошибка

ƒалее выполн€ем тест нашей сети. (Ќадстройка: Test Network -> TestЕ)



ѕосле окончани€ тестировани€ будут созданы листы: (Test Report и Test IOData)



PS: ќбучение нейронной сети Ц сложный вычислительный процесс, который может занимать от нескольких часов до нескольких суток.


--------------------
Ќикто не может вернутьс€ назад, начать все с начала и изменить прошлое, но любой может начать сейчас и изменить будущее.
ѕерейти в начало страницы
 
+÷итировать сообщение
Admin
сообщение 8.8.2009, 1:27
—ообщение #12


јлхимик
»конка группы

√руппа: √лавные јдминистраторы
—ообщений: 5976
–епутаци€: 13
–егистраци€: 5.8.2008
»з: »спани€
ѕользователь є: 1
—пасибо сказали: 4610 раз(а)




Ќа листе Test IOData мы можем видеть результат работы сети на тестовом периоде (столбец УO OutputФ).



ѕроведем тестирование всех сформированных архитектур и скопируем полученные УO OutputФ на один лист к нашим исходным данным.



–ассчитаем ошибку прогнозировани€, добавив столбцы УEФ, в которых выведем модуль (абсолютное значение) разницы между значени€ми реального показател€ УOФ и прогнозируемого Уќ OutputФ.

ѕример формулы дл€ Microsoft Excel: =ABS(A2-B2)

¬ конце каждого столбца рассчитаем среднее арифметическое данной ошибки.

¬ыбераем ту сеть, котора€ совершала прогноз с наименьшей ошибкой:
(¬ нашем случае это сеть N9)



“.к. дл€ построени€ торговой системы нас интересует прогнозирование направлени€ движени€, а не точность абсолютных значений, добавим столбцы с показател€ми верных направлений.

  • ≈сли изменение положительное, и сеть сделала прогноз положительного изменени€, то прогноз верный. (ставим 1)
  • ≈сли изменение отрицательное, и сеть сделала прогноз отрицательного изменени€, то прогноз верный. (ставим 1)


¬ остальных случа€х:

  • ≈сли изменение положительное, а сеть сделала прогноз отрицательно изменени€ то прогноз неверный. (ставим 0)
  • ≈сли изменение отрицательное, а сеть сделала прогноз положительного изменени€, то прогноз неверный. (ставим 0)


¬ формате Microsoft Excel данна€ формула будет выгл€деть так:

=≈—Ћ»(»Ћ»(»(A2>0;B2>0);»(A2<0;B2<0));1;0)
√де A2 Ц реальное значение, B2 Ц прогнозируемое значение.



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

¬ыбераем ту сеть, котора€ показала наибольший процент верных прогнозов:
(¬ нашем случае это сеть N9)



—равним показатели средней квадратичной ошибки.

Ћидером среди архитектур оказалась сеть є9 давша€ 59.5% побед!
(при подстановке в исходные данные случайного набора цен не из тестируемого периода, показатель побед колеблетс€ от 49% до 51%).

ѕоказатель 59.51% лежит вне этого диапазона и дает нам статистическое преимущество, на базе которого возможно построить торговую систему с положительным математическим ожиданием.


--------------------
Ќикто не может вернутьс€ назад, начать все с начала и изменить прошлое, но любой может начать сейчас и изменить будущее.
ѕерейти в начало страницы
 
+÷итировать сообщение
Admin
сообщение 11.8.2009, 20:28
—ообщение #13


јлхимик
»конка группы

√руппа: √лавные јдминистраторы
—ообщений: 5976
–епутаци€: 13
–егистраци€: 5.8.2008
»з: »спани€
ѕользователь є: 1
—пасибо сказали: 4610 раз(а)




ƒл€ использовани€ и дальнейшего тестировани€ сети мы можем настроить поток котировок в Microsoft Excel через DDE.

Ќапример, из MetaTrader 4 (ƒистрибутив можно скачать с сайта www.metaquotes.ru)

ƒл€ этого необходимо в настройках MetaTrader поставить УгалочкуФ на DDE сервер (У—ервис - Ќастройки - ¬ключить DDE серверФ или УOptions Ч Server Ч Enable DDE Server"), после чего необходимо перезагрузить MetaTrader.



ƒл€ приема данных в Microsoft Excel надо добавить в необходимую €чейку формулы вида

запрос BID: =MT4|BID!USDCHF
запрос ASK: =MT4|ASK!USDCHF
запрос HIGH: =MT4|HIGH!USDCHF
запрос LOW: =MT4|LOW!USDCHF
запрос TIME: =MT4|TIME!USDCHF
запрос QUOTE: =MT4|QUOTE!USDCHF

ѕолный пример использовани€ DDE находитс€ в дистрибутиве терминала в файле DDE-Sample.xls

ƒл€ сохранени€ котировок в Microsoft Excel можно воспользоватьс€ VBA скриптом:

CODE

'----------------------
'создаем глобальную переменную дл€ управлени€ программой
Public StartStop As Integer
'----------------------
'код дл€ кнопки &quot;—тарт&quot;
Private Sub CommandButton1_Click()
Dim PauseTime, Start
Dim LastQuote As String
'передаем переменной значение времени паузы
PauseTime = UserForm1.TextBox1.Value
'устанавливаем курсор на €чейку под которой будут записыватс€ данные
Range(&quot;QUOTE_COLLECT&quot;).Select
StartStop = 1
'запускаем цикл обращени€ к €чейке с данными из дде
Do While StartStop = 1
'перемещаем курсор на одну €чейку вниз
ActiveCell.Offset(1, 0).Select
'записываем в переменную значение котировок
LastQuote = Range(&quot;GBPUSD_QUOTE&quot;).Value
'записываем в переменную значение текущего времени в секундах
Start = Timer
'запускаем цикл дл€ задержки времени (по дефолту 1 секунда)
Do While Timer &lt; Start + PauseTime
DoEvents
Loop
'спуст€ одну секунду, записываем значение котировок в нужном месте
ActiveCell.Value = LastQuote
'находимс€ в цикле пока переменна€ StartStop = 1
Loop
End Sub
'--------------------------
'код дл€ кнопки &quot;—топ&quot;
Private Sub CommandButton2_Click()
'передаем переменной значение 2 дл€ остановки цикла
StartStop = 2
'закрываем форму
Unload Me
End Sub
'--------------------------


ѕолный текст УMetaTrader4-DDE-Excel 2007 —охранение  отировок на ЋистеФ доступен по адресу: http://www.myspreadsheet.info/metatrader4-...k-na-liste.html


--------------------
Ќикто не может вернутьс€ назад, начать все с начала и изменить прошлое, но любой может начать сейчас и изменить будущее.
ѕерейти в начало страницы
 
+÷итировать сообщение
Admin
сообщение 11.8.2009, 21:07
—ообщение #14


јлхимик
»конка группы

√руппа: √лавные јдминистраторы
—ообщений: 5976
–епутаци€: 13
–егистраци€: 5.8.2008
»з: »спани€
ѕользователь є: 1
—пасибо сказали: 4610 раз(а)




ƒл€ дальнейшего использовани€ нейронной сети вне Microsoft Excel, нам необходимо собрать ее в виде отдельной DLL библиотеки.

ƒл€ компил€ции нам понадобитс€ Microsoft Visual Studio, а конкретно Microsoft Visual C++
Ќиже представлен исходный код примера программы использовани€ DLL

NSNetwork.cpp
CODE

//===========================================================================
// Includes
//===========================================================================
#include "stdafx.h"
#include "NSNetwork.h"

//===========================================================================
//===========================================================================
// CLASS: NSNetwork
//===========================================================================
//===========================================================================

//---------------------------------------------------------------------------
// CLASS: NSNetwork FUNCTION: <constructor> (LPCSTR)
//---------------------------------------------------------------------------
NSNetwork::NSNetwork(LPCSTR dllPathName)
{
//---------------------------------------------------------------------------
// Load the neural network DLL.
//---------------------------------------------------------------------------
m_hDLL = LoadLibrary(dllPathName);
m_pNetworkInstance = 0;

//---------------------------------------------------------------------------
// If the DLL load was successful, get the addresses of the DLL functions.
//---------------------------------------------------------------------------
if (m_hDLL)
{
//---------------------------------------------------------------------------
// Load functions common to both RECALL and LEARNING DLLs.
//---------------------------------------------------------------------------
m_NSCreateNetwork = (NSCreateNetwork)GetProcAddress(m_hDLL, "createNetwork");
m_NSDestroyNetwork = (NSDestroyNetwork)GetProcAddress(m_hDLL, "destroyNetwork");
m_NSGetInputOutputInfo = (NSGetInputOutputInfo)GetProcAddress(m_hDLL, "getInputOutputInfo");
m_NSGetResponse = (NSGetResponse)GetProcAddress(m_hDLL, "getResponse");
m_NSGetSensitivity = (NSGetSensitivity)GetProcAddress(m_hDLL, "getSensitivity");
m_NSLoadWeights = (NSLoadWeights)GetProcAddress(m_hDLL, "loadWeights");
m_NSSaveWeights = (NSSaveWeights)GetProcAddress(m_hDLL, "saveWeights");
m_NSRandomizeWeights = (NSRandomizeWeights)GetProcAddress(m_hDLL, "randomizeWeights");
m_NSResetNetwork = (NSResetNetwork)GetProcAddress(m_hDLL, "resetNetwork");

//---------------------------------------------------------------------------
// Verify functions common to both RECALL and LEARNING DLLs loaded correctly.
//---------------------------------------------------------------------------
if (!m_NSCreateNetwork ||
!m_NSDestroyNetwork ||
!m_NSGetInputOutputInfo ||
!m_NSGetResponse ||
!m_NSGetSensitivity ||
!m_NSLoadWeights ||
!m_NSSaveWeights ||
!m_NSRandomizeWeights ||
!m_NSResetNetwork)
{
FreeLibrary(m_hDLL);
m_hDLL = 0;
}
}
}

//---------------------------------------------------------------------------
// CLASS: NSNetwork FUNCTION: <destructor>
//---------------------------------------------------------------------------
NSNetwork::~NSNetwork()
{
//---------------------------------------------------------------------------
// If the network instance is still set, release it.
//---------------------------------------------------------------------------
if (IsInitialized())
{
m_NSDestroyNetwork(m_pNetworkInstance);
m_pNetworkInstance = 0;
}

//---------------------------------------------------------------------------
// Release the neural network DLL if it is loaded.
//---------------------------------------------------------------------------
if (IsLoaded())
{
FreeLibrary(m_hDLL);
m_hDLL = 0;
}
}

//---------------------------------------------------------------------------
// CLASS: NSNetwork FUNCTION: GetInputs()
//---------------------------------------------------------------------------
// Return the number of inputs for the generated DLL or -1 on failure.
//---------------------------------------------------------------------------
int NSNetwork::GetInputs()
{
int numInputs;
int numOutputs;
if (!IsInitialized())
return -1;
if (m_NSGetInputOutputInfo(m_pNetworkInstance,numInputs,numOutputs))
return -1;
return numInputs;
}

//---------------------------------------------------------------------------
// CLASS: NSNetwork FUNCTION: GetOutputs()
//---------------------------------------------------------------------------
// Return the number of outputs for the generated DLL or -1 on failure.
//---------------------------------------------------------------------------
int NSNetwork::GetOutputs()
{
int numInputs;
int numOutputs;
if (!IsInitialized())
return -1;
if (m_NSGetInputOutputInfo(m_pNetworkInstance,numInputs,numOutputs))
return -1;
return numOutputs;
}

//---------------------------------------------------------------------------
// CLASS: NSNetwork FUNCTION: GetInputOutputInfo(int,int)
//---------------------------------------------------------------------------
// Obtain the number of inputs and outputs for the generated DLL.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSNetwork::GetInputOutputInfo(int& numInputs, int& numOutputs)
{
if (!IsInitialized())
return -1;
return m_NSGetInputOutputInfo(m_pNetworkInstance,numInputs,numOutputs);
}

//---------------------------------------------------------------------------
// CLASS: NSNetwork FUNCTION: GetResponse(int,double*,double*)
//---------------------------------------------------------------------------
// Obtain the neural network response to a set of input data.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSNetwork::GetResponse(int exemplars, double* inputData, double* outputData)
{
if (!IsInitialized())
return -1;
return m_NSGetResponse(m_pNetworkInstance,exemplars,inputData,outputData);
}

//---------------------------------------------------------------------------
// CLASS: NSNetwork FUNCTION: GetSensitivity(int,double*,double*,double)
//---------------------------------------------------------------------------
// Obtain the neural network sensitivity to a set of input data.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSNetwork::GetSensitivity(int exemplars, double* inputData, double* sensitivityData, double dither)
{
if (!IsInitialized())
return -1;
return m_NSGetSensitivity(m_pNetworkInstance,exemplars,inputData,sensitivityData,dither
);
}

//---------------------------------------------------------------------------
// CLASS: NSNetwork FUNCTION: LoadWeights(LPCSTR)
//---------------------------------------------------------------------------
// Load a weights file.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSNetwork::LoadWeights(LPCSTR pathName)
{
if (!IsInitialized())
return -1;
return m_NSLoadWeights(m_pNetworkInstance,pathName);
}

//---------------------------------------------------------------------------
// CLASS: NSNetwork FUNCTION: RandomizeWeights()
//---------------------------------------------------------------------------
// Randomize the weights in the network.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSNetwork::RandomizeWeights()
{
if (!IsInitialized())
return -1;
return m_NSRandomizeWeights(m_pNetworkInstance);
}

//---------------------------------------------------------------------------
// CLASS: NSNetwork FUNCTION: ResetNetwork()
//---------------------------------------------------------------------------
// Reset the network.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSNetwork::ResetNetwork()
{
if (!IsInitialized())
return -1;
return m_NSResetNetwork(m_pNetworkInstance);
}

//---------------------------------------------------------------------------
// CLASS: NSNetwork FUNCTION: SaveWeights(LPCSTR)
//---------------------------------------------------------------------------
// Save a weights file.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSNetwork::SaveWeights(LPCSTR pathName)
{
if (!IsInitialized())
return -1;
return m_NSSaveWeights(m_pNetworkInstance,pathName);
}

//===========================================================================
//===========================================================================
// CLASS: NSLearningNetwork
//===========================================================================
//===========================================================================

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: <constructor> (LPCSTR)
//---------------------------------------------------------------------------
NSLearningNetwork::NSLearningNetwork(LPCSTR dllPathName):
NSNetwork(dllPathName)
{
//---------------------------------------------------------------------------
// If the DLL load was successful, get the addresses of the learning DLL functions.
//---------------------------------------------------------------------------
if (IsLoaded())
{
//---------------------------------------------------------------------------
// Load functions unique to learning DLLs.
//---------------------------------------------------------------------------
m_NSTrain = (NSTrain)GetProcAddress(m_hDLL, "train");
m_NSGetBestCost = (NSGetBestCost)GetProcAddress(m_hDLL, "getBestCost");
m_NSSetBestCost = (NSSetBestCost)GetProcAddress(m_hDLL, "setBestCost");
m_NSGetBestWeightsPathName = (NSGetBestWeightsPathName)GetProcAddress(m_hDLL, "getBestWeightsPathName");
m_NSSetBestWeightsPathName = (NSSetBestWeightsPathName)GetProcAddress(m_hDLL, "setBestWeightsPathName");
m_NSGetSaveBestWeightsEnabled = (NSGetSaveBestWeightsEnabled)GetProcAddress(m_hDLL, "getSaveBestWeightsEnabled");
m_NSSetSaveBestWeightsEnabled = (NSSetSaveBestWeightsEnabled)GetProcAddress(m_hDLL, "setSaveBestWeightsEnabled");
m_NSGetSaveBestWeightsForTraining = (NSGetSaveBestWeightsForTraining)GetProcAddress(m_hDLL, "getSaveBestWeightsForTraining");
m_NSSetSaveBestWeightsForTraining = (NSSetSaveBestWeightsForTraining)GetProcAddress(m_hDLL, "setSaveBestWeightsForTraining");
m_NSGetCrossValidationEnabled = (NSGetCrossValidationEnabled)GetProcAddress(m_hDLL, "getCrossValidationEnabled");
m_NSSetCrossValidationEnabled = (NSSetCrossValidationEnabled)GetProcAddress(m_hDLL, "setCrossValidationEnabled");
m_NSGetAutoComputeInputNormCoeff = (NSGetAutoComputeInputNormCoeff)GetProcAddress(m_hDLL, "getAutoComputeInputNormCoeff");
m_NSSetAutoComputeInputNormCoeff = (NSSetAutoComputeInputNormCoeff)GetProcAddress(m_hDLL, "setAutoComputeInputNormCoeff");
m_NSGetAutoComputeOutputNormCoeff = (NSGetAutoComputeOutputNormCoeff)GetProcAddress(m_hDLL, "getAutoComputeOutputNormCoeff");
m_NSSetAutoComputeOutputNormCoeff = (NSSetAutoComputeOutputNormCoeff)GetProcAddress(m_hDLL, "setAutoComputeOutputNormCoeff");
m_NSRemoveInputNormalization = (NSRemoveInputNormalization)GetProcAddress(m_hDLL, "removeInputNormalization");
m_NSRemoveOutputNormalization = (NSRemoveOutputNormalization)GetProcAddress(m_hDLL, "removeOutputNormalization");
m_NSGetInputNormMin = (NSGetInputNormMin)GetProcAddress(m_hDLL, "getInputNormMin");
m_NSSetInputNormMin = (NSSetInputNormMin)GetProcAddress(m_hDLL, "setInputNormMin");
m_NSGetInputNormMax = (NSGetInputNormMax)GetProcAddress(m_hDLL, "getInputNormMax");
m_NSSetInputNormMax = (NSSetInputNormMax)GetProcAddress(m_hDLL, "setInputNormMax");
m_NSGetOutputNormMin = (NSGetOutputNormMin)GetProcAddress(m_hDLL, "getOutputNormMin");
m_NSSetOutputNormMin = (NSSetOutputNormMin)GetProcAddress(m_hDLL, "setOutputNormMin");
m_NSGetOutputNormMax = (NSGetOutputNormMax)GetProcAddress(m_hDLL, "getOutputNormMax");
m_NSSetOutputNormMax = (NSSetOutputNormMax)GetProcAddress(m_hDLL, "setOutputNormMax");
m_NSGetNormalizeInputByChannel = (NSGetNormalizeInputByChannel)GetProcAddress(m_hDLL, "getNormalizeInputByChannel");
m_NSSetNormalizeInputByChannel = (NSSetNormalizeInputByChannel)GetProcAddress(m_hDLL, "setNormalizeInputByChannel");
m_NSGetNormalizeOutputByChannel = (NSGetNormalizeOutputByChannel)GetProcAddress(m_hDLL, "getNormalizeOutputByChannel");
m_NSSetNormalizeOutputByChannel = (NSSetNormalizeOutputByChannel)GetProcAddress(m_hDLL, "setNormalizeOutputByChannel");
m_NSGetCrossValidationCostData = (NSGetCrossValidationCostData)GetProcAddress(m_hDLL, "getCrossValidationCostData");
m_NSGetCostData = (NSGetCostData)GetProcAddress(m_hDLL, "getCostData");
m_NSGetNumberOfEpochsTrained = (NSGetNumberOfEpochsTrained)GetProcAddress(m_hDLL, "getNumberOfEpochsTrained");
m_NSGetEpochOfBestCost = (NSGetEpochOfBestCost)GetProcAddress(m_hDLL, "getEpochOfBestCost");
m_NSSeedRandom = (NSSeedRandom)GetProcAddress(m_hDLL, "seedRandom");

//---------------------------------------------------------------------------
// Verify functions unique to learning DLLs loaded correctly.
// Note: Do not free DLL on failure so that caller can use IsLoaded()/IsInitialized().
//---------------------------------------------------------------------------
if (!m_NSTrain ||
!m_NSGetBestCost ||
!m_NSSetBestCost ||
!m_NSGetBestWeightsPathName ||
!m_NSSetBestWeightsPathName ||
!m_NSGetSaveBestWeightsEnabled ||
!m_NSSetSaveBestWeightsEnabled ||
!m_NSGetSaveBestWeightsForTraining ||
!m_NSSetSaveBestWeightsForTraining ||
!m_NSGetCrossValidationEnabled ||
!m_NSSetCrossValidationEnabled ||
!m_NSGetAutoComputeInputNormCoeff ||
!m_NSSetAutoComputeInputNormCoeff ||
!m_NSGetAutoComputeOutputNormCoeff ||
!m_NSSetAutoComputeOutputNormCoeff ||
!m_NSRemoveInputNormalization ||
!m_NSRemoveOutputNormalization ||
!m_NSGetInputNormMin ||
!m_NSSetInputNormMin ||
!m_NSGetInputNormMax ||
!m_NSSetInputNormMax ||
!m_NSGetOutputNormMin ||
!m_NSSetOutputNormMin ||
!m_NSGetOutputNormMax ||
!m_NSSetOutputNormMax ||
!m_NSGetNormalizeInputByChannel ||
!m_NSSetNormalizeInputByChannel ||
!m_NSGetNormalizeOutputByChannel ||
!m_NSSetNormalizeOutputByChannel ||
!m_NSGetCrossValidationCostData ||
!m_NSGetCostData ||
!m_NSGetNumberOfEpochsTrained ||
!m_NSGetEpochOfBestCost ||
!m_NSSeedRandom)
{
}
//---------------------------------------------------------------------------
// If all functions available, create an instance of the neural network.
//---------------------------------------------------------------------------
else
{
m_NSCreateNetwork(m_pNetworkInstance,LEARNING);
}
}
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: RemoveInputNormalization()
//---------------------------------------------------------------------------
// Remove the normalization of the input data.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSLearningNetwork::RemoveInputNormalization()
{
if (!IsInitialized())
return -1;
return m_NSRemoveInputNormalization(m_pNetworkInstance);
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: RemoveOutputNormalization()
//---------------------------------------------------------------------------
// Remove the normalization of the output data.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSLearningNetwork::RemoveOutputNormalization()
{
if (!IsInitialized())
return -1;
return m_NSRemoveOutputNormalization(m_pNetworkInstance);
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: SeedRandom(unsigned int)
//---------------------------------------------------------------------------
// Seed the random number generator.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSLearningNetwork::SeedRandom(unsigned int seed)
{
if (!IsInitialized())
return -1;
return m_NSSeedRandom(m_pNetworkInstance, seed);
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: Train(int,int,double*,double*)
//---------------------------------------------------------------------------
// Train the network without cross-validation.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSLearningNetwork::Train(int epochs, int exemplars, double* inputData, double* desiredData)
{
if (!IsInitialized())
return -1;
return m_NSTrain(m_pNetworkInstance,epochs,exemplars,inputData,desiredData,0,0,0);
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: Train(int,int,double*,double*,int,double*,double*)
//---------------------------------------------------------------------------
// Train the network with cross-validation.
// NOTE: SetCrossValidationEnabled(true) must be called for cross-validation to be activated.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSLearningNetwork::Train(int epochs, int exemplars, double* inputData, double* desiredData, int cvExemplars, double* cvInputData, double* cvDesiredData)
{
if (!IsInitialized())
return -1;
return m_NSTrain(m_pNetworkInstance,epochs,exemplars,inputData,desiredData,cvExemplars,
cvInputData,cvDesiredData);
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: GetAutoComputeInputNormCoeff()
//---------------------------------------------------------------------------
// Return whether or not the input normalization coefficients will
// automatically be calculated.
//---------------------------------------------------------------------------
bool NSLearningNetwork::GetAutoComputeInputNormCoeff()
{
if (!IsInitialized())
return false;
bool autoComputeInputNormCoeff;
if (m_NSGetAutoComputeInputNormCoeff(m_pNetworkInstance,autoComputeInputNormCoeff))
return false;
return autoComputeInputNormCoeff;
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: GetAutoComputeOutputNormCoeff()
//---------------------------------------------------------------------------
// Return whether or not the output normalization coefficients will
// automatically be calculated.
//---------------------------------------------------------------------------
bool NSLearningNetwork::GetAutoComputeOutputNormCoeff()
{
if (!IsInitialized())
return false;
bool autoComputeOutputNormCoeff;
if (m_NSGetAutoComputeOutputNormCoeff(m_pNetworkInstance,autoComputeOutputNormCoeff
))
return false;
return autoComputeOutputNormCoeff;
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: GetBestCost()
//---------------------------------------------------------------------------
// Return the best cost or -1 on failure.
//---------------------------------------------------------------------------
double NSLearningNetwork::GetBestCost()
{
double bestCost;
if (!IsInitialized())
return -1;
if (m_NSGetBestCost(m_pNetworkInstance,bestCost))
return -1;
return bestCost;
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: GetBestWeightsPathName()
//---------------------------------------------------------------------------
// Return the best weights path name or an empty string on failure.
//---------------------------------------------------------------------------
CString NSLearningNetwork::GetBestWeightsPathName()
{
char buffer[1024];
int bufferUsed;
if (!IsInitialized())
return "";
if (m_NSGetBestWeightsPathName(m_pNetworkInstance,buffer,sizeof(buffer),bufferUsed)
)
return "";
return buffer;
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: GetCostData(double *)
//---------------------------------------------------------------------------
// Fills the costData array with the training learning curve (an array of cost
// data for the training dataset). You must allocate the memory for the cost
// data before passing its pointer to this function. Use GetNumberOfEpochsTrained
// to determine the necessary size of the array.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSLearningNetwork::GetCostData(double *costData)
{
if (!IsInitialized())
return -1;
return m_NSGetCostData(m_pNetworkInstance, costData);
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: GetCrossValidationCostData(double *)
//---------------------------------------------------------------------------
// Fills the CVCostData array with the cross validation learning curve (an
// array of cost data for the cross validation dataset). You must allocate
// the memory for the cost data before passing its pointer to this function.
// Use GetNumberOfEpochsTrained to determine the necessary size of the array.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSLearningNetwork::GetCrossValidationCostData(double *CVCostData)
{
if (!IsInitialized())
return -1;
return m_NSGetCrossValidationCostData(m_pNetworkInstance, CVCostData);
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: GetCrossValidationEnabled()
//---------------------------------------------------------------------------
// Return whether or not cross validation will be used during training.
//---------------------------------------------------------------------------
bool NSLearningNetwork::GetCrossValidationEnabled()
{
if (!IsInitialized())
return false;
bool crossValidationEnabled;
if (m_NSGetCrossValidationEnabled(m_pNetworkInstance,crossValidationEnabled))
return false;
return crossValidationEnabled;
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: GetEpochOfBestCost()
//---------------------------------------------------------------------------
// Return the epoch during which the best cost was obtained.
//---------------------------------------------------------------------------
int NSLearningNetwork::GetEpochOfBestCost()
{
if (!IsInitialized())
return -1;
int epochOfBestCost;
m_NSGetEpochOfBestCost(m_pNetworkInstance, epochOfBestCost);
return epochOfBestCost;
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: GetInputNormMax()
//---------------------------------------------------------------------------
// Returns the upper bound for the input normalization.
//---------------------------------------------------------------------------
double NSLearningNetwork::GetInputNormMax()
{
if (!IsInitialized())
return -1;
double inputNormMax;
m_NSGetInputNormMax(m_pNetworkInstance, inputNormMax);
return inputNormMax;
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: GetInputNormMin()
//---------------------------------------------------------------------------
// Returns the lower bound for the input normalization.
//---------------------------------------------------------------------------
double NSLearningNetwork::GetInputNormMin()
{
if (!IsInitialized())
return -1;
double inputNormMin;
m_NSGetInputNormMin(m_pNetworkInstance, inputNormMin);
return inputNormMin;
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: GetNormalizeInputByChannel()
//---------------------------------------------------------------------------
// Return whether or not the input normalization coefficients will
// calculated by channel (for each column of data individually) or across the
// entire input dataset.
//---------------------------------------------------------------------------
bool NSLearningNetwork::GetNormalizeInputByChannel()
{
if (!IsInitialized())
return false;
bool normalizeInputByChannel;
if (m_NSGetNormalizeInputByChannel(m_pNetworkInstance, normalizeInputByChannel))
return false;
return normalizeInputByChannel;
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: GetNormalizeOutputByChannel()
//---------------------------------------------------------------------------
// Return whether or not the output normalization coefficients will
// calculated by channel (for each column of data individually) or across the
// entire output dataset.
//---------------------------------------------------------------------------
bool NSLearningNetwork::GetNormalizeOutputByChannel()
{
if (!IsInitialized())
return false;
bool normalizeOutputByChannel;
if (m_NSGetNormalizeOutputByChannel(m_pNetworkInstance, normalizeOutputByChannel))
return false;
return normalizeOutputByChannel;
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: GetNumberOfEpochsTrained()
//---------------------------------------------------------------------------
// Returns the number of epochs that the network has been trained for (the
// network may not train for the complete number of epochs set due to the
// existance of transmitters that may stop the network early).
//---------------------------------------------------------------------------
int NSLearningNetwork::GetNumberOfEpochsTrained()
{
if (!IsInitialized())
return -1;
int numberOfEpochsTrained;
m_NSGetNumberOfEpochsTrained(m_pNetworkInstance, numberOfEpochsTrained);
return numberOfEpochsTrained;
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: GetOutputNormMax()
//---------------------------------------------------------------------------
// Returns the upper bound for the output normalization.
//---------------------------------------------------------------------------
double NSLearningNetwork::GetOutputNormMax()
{
if (!IsInitialized())
return -1;
double outputNormMax;
m_NSGetOutputNormMax(m_pNetworkInstance, outputNormMax);
return outputNormMax;
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: GetOutputNormMin()
//---------------------------------------------------------------------------
// Returns the upper bound for the output normalization.
//---------------------------------------------------------------------------
double NSLearningNetwork::GetOutputNormMin()
{
if (!IsInitialized())
return -1;
double outputNormMin;
m_NSGetOutputNormMin(m_pNetworkInstance, outputNormMin);
return outputNormMin;
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: GetSaveBestWeightsEnabled()
//---------------------------------------------------------------------------
// Return whether or not the best weights will be saved during training.
//---------------------------------------------------------------------------
bool NSLearningNetwork::GetSaveBestWeightsEnabled()
{
bool saveBestWeightsEnabled;
if (!IsInitialized())
return false;
if (m_NSGetSaveBestWeightsEnabled(m_pNetworkInstance,saveBestWeightsEnabled))
return false;
return saveBestWeightsEnabled;
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: GetSaveBestWeightsForTraining()
//---------------------------------------------------------------------------
// Return whether the best weights will be saved for training or cross validation.
//---------------------------------------------------------------------------
bool NSLearningNetwork::GetSaveBestWeightsForTraining()
{
bool saveBestWeightsForTraining;
if (!IsInitialized())
return false;
if (m_NSGetSaveBestWeightsForTraining(m_pNetworkInstance,saveBestWeightsForTraining
))
return false;
return saveBestWeightsForTraining;
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: SetAutoComputeInputNormCoeff(bool)
//---------------------------------------------------------------------------
// Turn the auto-computation of input normalization coefficients on or off.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSLearningNetwork::SetAutoComputeInputNormCoeff(bool autoComputeInputNormCoeff)
{
if (!IsInitialized())
return -1;
return m_NSSetAutoComputeInputNormCoeff(m_pNetworkInstance, autoComputeInputNormCoeff);
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: SetAutoComputeOutputNormCoeff(bool)
//---------------------------------------------------------------------------
// Turn the auto-computation of output normalization coefficients on or off.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSLearningNetwork::SetAutoComputeOutputNormCoeff(bool autoComputeOutputNormCoeff)
{
if (!IsInitialized())
return -1;
return m_NSSetAutoComputeOutputNormCoeff(m_pNetworkInstance, autoComputeOutputNormCoeff);
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: SetBestCost(double)
//---------------------------------------------------------------------------
// Set the best cost.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSLearningNetwork::SetBestCost(double bestCost)
{
if (!IsInitialized())
return -1;
return m_NSSetBestCost(m_pNetworkInstance,bestCost);
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: SetBestWeightsPathName(LPCSTR)
//---------------------------------------------------------------------------
// Set the path name to save the best weights to.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSLearningNetwork::SetBestWeightsPathName(LPCSTR pathName)
{
if (!IsInitialized())
return -1;
return m_NSSetBestWeightsPathName(m_pNetworkInstance,pathName);
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: SetCrossValidationEnabled(bool)
//---------------------------------------------------------------------------
// Turn the cross-validation on or off.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSLearningNetwork::SetCrossValidationEnabled(bool crossValidationEnabled)
{
if (!IsInitialized())
return -1;
return m_NSSetCrossValidationEnabled(m_pNetworkInstance,crossValidationEnabled);
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: SetInputNormMax(double)
//---------------------------------------------------------------------------
// Sets the upper bound for the input normalization.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSLearningNetwork::SetInputNormMax(double inputNormMax)
{
if (!IsInitialized())
return -1;
return m_NSSetInputNormMax(m_pNetworkInstance, inputNormMax);
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: SetInputNormMin(double)
//---------------------------------------------------------------------------
// Sets the lower bound for the input normalization.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSLearningNetwork::SetInputNormMin(double inputNormMin)
{
if (!IsInitialized())
return -1;
return m_NSSetInputNormMin(m_pNetworkInstance, inputNormMin);
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: SetNormalizeInputByChannel(bool)
//---------------------------------------------------------------------------
// Turn by-channel normalization of the input data on or off.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSLearningNetwork::SetNormalizeInputByChannel(bool normalizeInputByChannel)
{
if (!IsInitialized())
return -1;
return m_NSSetNormalizeInputByChannel(m_pNetworkInstance, normalizeInputByChannel);
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: SetNormalizeOutputByChannel(bool)
//---------------------------------------------------------------------------
// Turn by-channel normalization of the output data on or off.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSLearningNetwork::SetNormalizeOutputByChannel(bool normalizeOutputByChannel)
{
if (!IsInitialized())
return -1;
return m_NSSetNormalizeOutputByChannel(m_pNetworkInstance, normalizeOutputByChannel);
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: SetOutputNormMax(double)
//---------------------------------------------------------------------------
// Sets the upper bound for the output normalization.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSLearningNetwork::SetOutputNormMax(double outputNormMax)
{
if (!IsInitialized())
return -1;
return m_NSSetOutputNormMax(m_pNetworkInstance, outputNormMax);
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: SetOutputNormMin(double)
//---------------------------------------------------------------------------
// Sets the lower bound for the output normalization.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSLearningNetwork::SetOutputNormMin(double outputNormMin)
{
if (!IsInitialized())
return -1;
return m_NSSetOutputNormMin(m_pNetworkInstance, outputNormMin);
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: SetSaveBestWeightsEnabled(bool)
//---------------------------------------------------------------------------
// Turn the saving of the best weights on or off.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSLearningNetwork::SetSaveBestWeightsEnabled(bool saveBestWeightsEnabled)
{
if (!IsInitialized())
return -1;
return m_NSSetSaveBestWeightsEnabled(m_pNetworkInstance,saveBestWeightsEnabled);
}

//---------------------------------------------------------------------------
// CLASS: NSLearningNetwork FUNCTION: SetSaveBestWeightsForTraining(bool)
//---------------------------------------------------------------------------
// Turn the saving of the best weights for training on or off.
// Returns 0 on success, -1 if not initialized, or an error code from the DLL.
//---------------------------------------------------------------------------
int NSLearningNetwork::SetSaveBestWeightsForTraining(bool saveBestWeightsForTraining)
{
if (!IsInitialized())
return -1;
return m_NSSetSaveBestWeightsForTraining(m_pNetworkInstance,saveBestWeightsForTraining)
;
}

//===========================================================================
//===========================================================================
// CLASS: NSRecallNetwork
//===========================================================================
//===========================================================================

//---------------------------------------------------------------------------
// CLASS: NSRecallNetwork FUNCTION: <constructor> (LPCSTR)
//---------------------------------------------------------------------------
NSRecallNetwork::NSRecallNetwork(LPCSTR dllPathName):
NSNetwork(dllPathName)
{
//---------------------------------------------------------------------------
// If DLL loaded successfully, create an instance of the neural network.
//---------------------------------------------------------------------------
if (IsLoaded())
{
m_NSCreateNetwork(m_pNetworkInstance,RECALL);
}
}


VCPPShell.cpp
CODE

//===========================================================================
// Includes
//===========================================================================
#include "stdafx.h"
#include <string.h>
#include "VCPPShell.h"
#include "NSNetwork.h"
#include "Globals.h"

//===========================================================================
// Debug handling generated by MFC AppWizard.
//===========================================================================
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

//===========================================================================
//===========================================================================
// CLASS: CVCPPShellApp
//===========================================================================
//===========================================================================

//===========================================================================
// Global declaration of application generated by MFC AppWizard.
//===========================================================================
CVCPPShellApp theApp;

//===========================================================================
// CLASS: CVCPPShellApp MESSAGE MAP
//---------------------------------------------------------------------------
// Note: This mapping was built by the MFC AppWizard.
//===========================================================================
BEGIN_MESSAGE_MAP(CVCPPShellApp, CWinApp)
//{{AFX_MSG_MAP(CVCPPShellApp)
// NOTE - the ClassWizard will add and remove mapping macros here.
// DO NOT EDIT what you see in these blocks of generated code!
//}}AFX_MSG
ON_COMMAND(ID_HELP, CWinApp::OnHelp)
END_MESSAGE_MAP()

//===========================================================================
// CLASS: CVCPPShellApp FUNCTION: <constructor>()
//---------------------------------------------------------------------------
// Note: This function was built by the MFC AppWizard.
//===========================================================================
CVCPPShellApp::CVCPPShellApp()
{
}

//===========================================================================
// CLASS: CVCPPShellApp FUNCTION: InitInstance()
//---------------------------------------------------------------------------
// Note: This function was built by the MFC AppWizard.
//===========================================================================
BOOL CVCPPShellApp::InitInstance()
{
// Standard initialization
// If you are not using these features and wish to reduce the size
// of your final executable, you should remove from the following
// the specific initialization routines you do not need.

CVCPPShellDlg dlg;
m_pMainWnd = &dlg;
int nResponse = dlg.DoModal();
if (nResponse == IDOK)
{
// Place code here to handle when the dialog is
// dismissed with OK
}
else if (nResponse == IDCANCEL)
{
// Place code here to handle when the dialog is
// dismissed with Cancel
}

// Since the dialog has been closed, return FALSE so that we exit the
// application, rather than start the application's message pump.
return FALSE;
}

//===========================================================================
//===========================================================================
// CLASS: CVCPPShellDlg
//===========================================================================
//===========================================================================

//===========================================================================
// CLASS: CVCPPShellDlg FUNCTION: <constructor>(CWnd*)
//---------------------------------------------------------------------------
// Note: This function was built by the MFC AppWizard.
//===========================================================================
CVCPPShellDlg::CVCPPShellDlg(CWnd* pParent /*=NULL*/)
: CDialog(CVCPPShellDlg::IDD, pParent)
{
//{{AFX_DATA_INIT(CVCPPShellDlg)

//}}AFX_DATA_INIT
// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);

}

//===========================================================================
// CLASS: CVCPPShellDlg FUNCTION: DoDataExchange(CDataExchange*)
//---------------------------------------------------------------------------
// Note: This function was built by the MFC AppWizard.
//===========================================================================
void CVCPPShellDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CVCPPShellDlg)
DDX_Text(pDX, IDC_TRAIN_NETWORK_REPORT, m_TrainNetwork_Report);
//}}AFX_DATA_MAP
}


//===========================================================================
// CLASS: CVCPPShellDlg FUNCTION: FillArrayFromFile(LPCTSTR, int, int)
//===========================================================================
double *CVCPPShellDlg::FillArrayFromFile(LPCTSTR fName, int numRows, int numCols)
{
CStdioFile fl;
LPTSTR tmpBuffer = new char [250];

char *token; //pointer to string tokens to extract from file strings
char *delim = " ,\t\n"; //delimiter to use for string tokenizer

//create array to hold double values extracted from file
long numCells = numRows * numCols;
double *retArray = (double *)calloc (numCells, sizeof (double));
int curIndx = 0;

if (fl.Open(fName, CFile::modeRead))
{

//read file until end is reached
while (((fl.ReadString(tmpBuffer, 250)) != NULL) && ((curIndx < numCells)))
{
//tokenize string to extract double values as strings
token = strtok (tmpBuffer, delim);

while (token != NULL)
{
//convert token to double and store in array
retArray[curIndx] = (double) atof (token);
curIndx++;

//tokenize string to extract double values as strings
token = strtok (NULL, delim);

} //end token while


} //end fl.Open while

fl.Close();
} //end if

free (tmpBuffer);

return retArray;
} //end FillArrayFromFile


//===========================================================================
// CLASS: CVCPPShellDlg MESSAGE MAP
//---------------------------------------------------------------------------
// Note: This mapping was built by the MFC AppWizard.
//===========================================================================
BEGIN_MESSAGE_MAP(CVCPPShellDlg, CDialog)
//{{AFX_MSG_MAP(CVCPPShellDlg)
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
ON_BN_CLICKED(IDC_GET_NETWORK_OUTPUT, OnGetResponse)
ON_BN_CLICKED(IDC_TRAIN_NETWORK, OnTrainNetwork)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()


//===========================================================================
// CLASS: CVCPPShellDlg FUNCTION: OnInitDialog()
//---------------------------------------------------------------------------
// Note: This function was built by the MFC AppWizard.
//===========================================================================
BOOL CVCPPShellDlg::OnInitDialog()
{

CDialog::OnInitDialog();

// Set the icon for this dialog. The framework does this automatically
// when the application's main window is not a dialog
SetIcon(m_hIcon, TRUE); // Set big icon
SetIcon(m_hIcon, FALSE); // Set small icon

//dispaly initial message in Get Network Output Report edit box
CEdit *pGetNetworkOutputReportEditBox = (CEdit *) GetDlgItem (IDC_GET_NETWORK_OUTPUT_REPORT);
pGetNetworkOutputReportEditBox->SetWindowText(_T("Not tested."));

//disables training if the DLL only supports a recall network
if (RECALL_ONLY_NETWORK)
{
//disable Train Network button
CWnd *pTrainNetworkButton = (CWnd *) GetDlgItem (IDC_TRAIN_NETWORK);
pTrainNetworkButton->EnableWindow(FALSE);

//disable Reset Network Before Training check box
CButton *pResetNetworkCheckBox = (CButton *) GetDlgItem (IDC_RESET_NETWORK);
pResetNetworkCheckBox->EnableWindow(FALSE);

//dispaly initial message in Train Network Report edit box
CEdit *pTrainNetworkReportEditBox = (CEdit *) GetDlgItem (IDC_TRAIN_NETWORK_REPORT);
pTrainNetworkReportEditBox->SetWindowText(_T("Only Recall DLL Supported."));

m_TrainNetwork_Report = _T("Recall Network Only.");
}
else
{
//dispaly initial message in Train Network Report edit box
CEdit *pTrainNetworkReportEditBox = (CEdit *) GetDlgItem (IDC_TRAIN_NETWORK_REPORT);
pTrainNetworkReportEditBox->SetWindowText(_T("Not tested."));

m_TrainNetwork_Report = _T("Not tested.");
}

return TRUE; // return TRUE unless you set the focus to a control
}

//===========================================================================
// CLASS: CVCPPShellDlg FUNCTION: OnPaint()
//---------------------------------------------------------------------------
// Note: This function was built by the MFC AppWizard.
//---------------------------------------------------------------------------
// If you add a minimize button to your dialog, you will need the code below
// to draw the icon. For MFC applications using the document/view model,
// this is automatically done for you by the framework.
//===========================================================================
void CVCPPShellDlg::OnPaint()
{
if (IsIconic())
{
CPaintDC dc(this); // device context for painting

SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);

// Center icon in client rectangle
int cxIcon = GetSystemMetrics(SM_CXICON);
int cyIcon = GetSystemMetrics(SM_CYICON);
CRect rect;
GetClientRect(&rect);
int x = (rect.Width() - cxIcon + 1) / 2;
int y = (rect.Height() - cyIcon + 1) / 2;

// Draw the icon
dc.DrawIcon(x, y, m_hIcon);
}
else
{
CDialog::OnPaint();
}
}

//===========================================================================
// CLASS: CVCPPShellDlg FUNCTION: OnQueryDragIcon()
//---------------------------------------------------------------------------
// Note: This function was built by the MFC AppWizard.
//---------------------------------------------------------------------------
// The system calls this to obtain the cursor to display while the user drags
// the minimized window.
//===========================================================================
HCURSOR CVCPPShellDlg::OnQueryDragIcon()
{
return (HCURSOR) m_hIcon;
}

//===========================================================================
// CLASS: CVCPPShellDlg FUNCTION: OnGetResponse()
//---------------------------------------------------------------------------
// This function illustrates how the DLL generated by the Custom Solution
// Wizard can be used for getting the network response (output).
// Step by step instructions are given on how to use the generated DLL
// for this purpose. Read through comments carefully performing all of the
// REQUIRED ACTIONs as you get to them.
//===========================================================================
void CVCPPShellDlg::OnGetResponse()
{
//---------------------------------------------------------------------------
// Step 1: Create an instance of NSRecallNetwork.
//---------------------------------------------------------------------------
// IMPLEMENTATION NOTES: The DLL_PATH_NAME is defined in Globals.h
//---------------------------------------------------------------------------
// Following this call, IsInitialized() should return true.
// If IsInitialized() is false, check to make sure the path to the DLL is correct.
//---------------------------------------------------------------------------
// You could create an NSLearningNetwork object instead, if you have the
// Developers level of the Custom Solution Wizard and used it along with a
// NeuroSolutions breadboard capable of learning to generate the DLL.
// Both NSRecallNetwork and NSLearningNetwork support recall operations.
//---------------------------------------------------------------------------
NSRecallNetwork nn(DLL_PATH_NAME);

if (nn.IsInitialized())
{
//---------------------------------------------------------------------------
// Step 2: Get the size of the DLL (number of inputs and outputs)
//---------------------------------------------------------------------------
int inputs;
int outputs;
nn.GetInputOutputInfo(inputs,outputs);

//---------------------------------------------------------------------------
// Step 3: Load the initial network weights.
//---------------------------------------------------------------------------
// IMPLEMENTATION NOTES: The BEST_WEIGHTS_PATH_NAME is defined in Globals.h.
// The initial best weights file is an exact copy of the weights file that was
// saved when the DLL was generated. However, the best weights file will change
// with each run of the TrainNetwork function if the network is reset before
// training.
//---------------------------------------------------------------------------
nn.LoadWeights(BEST_WEIGHTS_PATH_NAME);

//---------------------------------------------------------------------------
// Step 4: Define the input data.
//---------------------------------------------------------------------------
// IMPLEMENTATION NOTES: The following loads the training input data from your initial
// network configuration into the array inputData.
// Note that the number of inputs in the input data must match the number of inputs
// expected by the generated DLL. Also, there can be any number of exemplars in the
// input data as long as the number of exemplars in the input data matches the number
// of exemplars in the desired data. In this case, NUMBER_OF_EXEMPLARS is defined in
// Globals.h.
//---------------------------------------------------------------------------
double *inputData = FillArrayFromFile(INPUT_FILE_PATH_NAME, inputs, NUMBER_OF_EXEMPLARS);

//---------------------------------------------------------------------------
// Step 5: Declare the storage for the response.
//---------------------------------------------------------------------------
// IMPLEMENTATION NOTES : The dimensions of the outputData array have been set
// to match the expected size of the output data.
//---------------------------------------------------------------------------
// Note: The first dimension of the outputData array is sized according
// to the number of outputs in the DLL. The second dimension of the outputData
// array is sized according to the number of exemplars in your data set as
// defined in Globals.h.
//---------------------------------------------------------------------------
double *outputData = (double *) calloc (outputs * NUMBER_OF_EXEMPLARS, sizeof (double));

//---------------------------------------------------------------------------
// Step 6: Get the network response to the input data.
//---------------------------------------------------------------------------
// IMPLEMENTATION NOTES: NUMBER_OF_EXEMPLARS is defined in Globals.h.
//---------------------------------------------------------------------------
nn.GetResponse(NUMBER_OF_EXEMPLARS, inputData, outputData);

//---------------------------------------------------------------------------
// Step 7: Verify the results. (Optional)
//---------------------------------------------------------------------------
// IMPLEMENTATION NOTES: Outputs the results to the Get Network Output Report edit box
//---------------------------------------------------------------------------
// Prepare edit box for output -> clear its contents.
CEdit *pGetNetworkOutputReportEditBox = (CEdit *) GetDlgItem (IDC_GET_NETWORK_OUTPUT_REPORT);
pGetNetworkOutputReportEditBox->SetWindowText(_T(""));

CString outStr = "Exemplar #\t";

// Add labels to top of edit box
for (int i = 1; i <= outputs; i++)
{
CString iAsStr;
iAsStr.Format ("%d \t", i);
outStr += "Output" + iAsStr;
}
outStr += "\r\n";

// Show outputs for all up to 1000 exemplars
int maxExemplars = (NUMBER_OF_EXEMPLARS > 1000)?1000:NUMBER_OF_EXEMPLARS;
for (int j = 0; j < maxExemplars; j++)
{
CString jAsStr;
jAsStr.Format("%d\t\t", j + 1);
outStr += jAsStr;

for (int k = 0; k < outputs; k++)
{
CString resultAsString;
resultAsString.Format("%9f\t", outputData[(j * outputs) + k]);
outStr += resultAsString;
} //end for j

outStr += "\r\n";
} //end for i


pGetNetworkOutputReportEditBox->SetWindowText(_T(outStr));

//---------------------------------------------------------------------------
// Perform some memory clean-up
//---------------------------------------------------------------------------
free (inputData);
free (outputData);

}
//---------------------------------------------------------------------------
// If initialization failed, report any errors here.
//---------------------------------------------------------------------------
else
{
//prepare edit box for output -> reset its contents
CEdit *pGetNetworkOutputReportEditBox = (CEdit *) GetDlgItem (IDC_GET_NETWORK_OUTPUT_REPORT);
pGetNetworkOutputReportEditBox->SetWindowText(_T("DLL Load Failed."));
}

//---------------------------------------------------------------------------
// Update the dialog.
//---------------------------------------------------------------------------
UpdateData(FALSE);
}

//===========================================================================
// CLASS: CVCPPShellDlg FUNCTION: OnTrainNetwork()
//---------------------------------------------------------------------------
// The function trains a learning network DLL and saves the best weights
// to a specified file for later use.
// Step by step instructions are given on how to use the generated DLL
// for this purpose. Read through comments carefully. The IMPLEMENTATION NOTES
// highlight parameters that you may wish to change in the future.
//---------------------------------------------------------------------------
// NOTE: This subroutine only applys to users of the Developers level of the
// Custom Solution Wizard. The Developers level allows the user to generate
// learning DLLs, whereas all other levels can only generate recall DLLs.
//===========================================================================
void CVCPPShellDlg::OnTrainNetwork()
{

//---------------------------------------------------------------------------
// Update Train Network Report edit box to indicate that the network is training.
//---------------------------------------------------------------------------
CEdit *pTrainNetworkReportEditBox = (CEdit *) GetDlgItem (IDC_TRAIN_NETWORK_REPORT);
pTrainNetworkReportEditBox->SetSel(0, -1, FALSE);
pTrainNetworkReportEditBox->ReplaceSel("Training...", FALSE);

//---------------------------------------------------------------------------
// Step 1: Create an instance of NSLearningNetwork.
//---------------------------------------------------------------------------
// IMPLEMENTATION NOTES: The path of the DLL is defined in Globals.h.
//---------------------------------------------------------------------------
// Following this call, IsInitialized() should return true.
// If IsInitialized() is false, one of the following errors occured:
// * The path to the DLL is incorrect. IsLoaded() will be false.
// * The path points a recall DLL. IsLoaded() will be true.
//---------------------------------------------------------------------------
// Note: This step will fail if you are not using the Developers level of
// the Custom Solution Wizard or if you generated the DLL using a recall
// NeuroSolutions breadboard.
//---------------------------------------------------------------------------
NSLearningNetwork nn(DLL_PATH_NAME);

if (nn.IsInitialized())
{
//---------------------------------------------------------------------------
// Step 2: Get the size of the DLL (number of inputs and outputs)
//---------------------------------------------------------------------------
int inputs;
int outputs;
nn.GetInputOutputInfo(inputs,outputs);

//---------------------------------------------------------------------------
// Step 3: Load the initial network weights. (Optional)
//---------------------------------------------------------------------------
// IMPLEMENTATION NOTES: The WEIGHTS_PATH_NAME has been defined in Globals.h to
// reflect that of the weights file that was saved when the DLL was generated.
//---------------------------------------------------------------------------
// Note: This step is not necessary. If this step is not performed, the
// network will simply start with random initial weights.
//---------------------------------------------------------------------------
nn.LoadWeights(WEIGHTS_PATH_NAME);

//---------------------------------------------------------------------------
// Resets the network (randomizes the network weights, etc.) if the user has so
// indicated by checking the "Reset Network Before Training" check box
//---------------------------------------------------------------------------
CButton *pResetNetworkCheckBox = (CButton *) GetDlgItem (IDC_RESET_NETWORK);
if (pResetNetworkCheckBox->GetCheck() == 1)
nn.ResetNetwork();

//---------------------------------------------------------------------------
// Step 4: Define the input data.
//---------------------------------------------------------------------------
// IMPLEMENTATION NOTES: The following loads the training input data from your initial
// network configuration into the array inputData.
// Note that the number of inputs in the input data must match the number of inputs
// expected by the generated DLL. Also, there can be any number of exemplars in the
// input data as long as the number of exemplars in the input data matches the number
// of exemplars in the desired data. In this case, NUMBER_OF_EXEMPLARS is defined in
// Globals.h.
//---------------------------------------------------------------------------
double *inputData = FillArrayFromFile(INPUT_FILE_PATH_NAME, inputs, NUMBER_OF_EXEMPLARS);

//---------------------------------------------------------------------------
// Step 5: Define the desired data.
//---------------------------------------------------------------------------
// IMPLEMENTATION NOTES: The following loads the training desired data from your initial
// network configuration into the array desiredData.
// Note that the number of outputs in the desired data must match the number of outputs
// expected by the generated DLL. Also, there can be any number of exemplars in the
// desired data as long as the number of exemplars in the desired data matches the number
// of exemplars in the input data. In this case, NUMBER_OF_EXEMPLARS is defined in
// Globals.h.
//---------------------------------------------------------------------------
double *desiredData = FillArrayFromFile(DESIRED_FILE_PATH_NAME, outputs, NUMBER_OF_EXEMPLARS);

//---------------------------------------------------------------------------
// Step 6: Enable the automatic saving of the best weights. (Optional)
//---------------------------------------------------------------------------
// Note: This step is not necessary. The default value of this property is
// always False. Setting it to True will cause the best network weights to be
// saved during training. If this property is set to True, be sure to call
// SetBestWeightsPathName() to set a valid path for the best weights (See Step 7).
//---------------------------------------------------------------------------
nn.SetSaveBestWeightsEnabled(true);

//---------------------------------------------------------------------------
// Step 7: Set the path for saving the best weights. (Optional)
//---------------------------------------------------------------------------
// IMPLEMENTATION NOTES : The BEST_WEIGHTS_PATH_NAME is defined in Globals.h.
//---------------------------------------------------------------------------
// Note: The specified path will be used for saving the best weights during
// training. This SetBestWeightsPathName() function must be set to a
// valid path if SetSaveBestWeightsEnabled() has been set to true. Otherwise,
// setting this property is optional.
//---------------------------------------------------------------------------
nn.SetBestWeightsPathName(BEST_WEIGHTS_PATH_NAME);

//---------------------------------------------------------------------------
// Step 8: Train the network.
//---------------------------------------------------------------------------
// IMPLEMENTATION NOTES : The NUMBER_OF_EPOCHS and NUMBER_OF_EXEMPLARS are defined
// in Globals.h and have been determined from the initial network configuration.
//---------------------------------------------------------------------------
// Note: Two versions of the Train() function are provided. This version does
// not include cross validation parameters. If cross validation is desired,
// use the other version of Train() and call SetCrossValidationEnabled(true).
//---------------------------------------------------------------------------
nn.Train(NUMBER_OF_EPOCHS, NUMBER_OF_EXEMPLARS, inputData, desiredData);

//---------------------------------------------------------------------------
// Step 9: Report best cost. (Optional)
//---------------------------------------------------------------------------
// This dialog-based application reports the best cost to the user.
//---------------------------------------------------------------------------
// Note: This step is not necessary, it is provided only to show how the best
// cost can be obtained.
//---------------------------------------------------------------------------
double bestCost = nn.GetBestCost();
m_TrainNetwork_Report.Format("Best Cost = %g",bestCost);

//---------------------------------------------------------------------------
// Perform some memory clean-up
//---------------------------------------------------------------------------
free (inputData);
free (desiredData);
}

//---------------------------------------------------------------------------
// If initialization failed, report any errors here.
//---------------------------------------------------------------------------
else
{
//---------------------------------------------------------------------------
// If the DLL was loaded, this is probably a recall-only network.
//---------------------------------------------------------------------------
if (nn.IsLoaded())
{
m_TrainNetwork_Report = "DLL recall only.";
}
//---------------------------------------------------------------------------
// Else, the DLL was not loaded, the path is probably incorrect.
//---------------------------------------------------------------------------
else
{
m_TrainNetwork_Report = "DLL load failed.";
}
}

//---------------------------------------------------------------------------
// Update the dialog.
//---------------------------------------------------------------------------
UpdateData(FALSE);
}


ѕолный архив с проектом дл€ Microsoft Visual C++ 6.0 : VCPP6ShellSource.zip

ѕример программы, полученной после компил€ции: VCPP6Shell.zip

» собственно итог проделанной нами работы: ћодуль Ќейронной —ети в виде DLL библиотеки:
ѕрикрепленный файл  RECURRENT_NETWORK.zip ( 97,71 килобайт )  ол-во скачиваний: 57


--------------------
Ќикто не может вернутьс€ назад, начать все с начала и изменить прошлое, но любой может начать сейчас и изменить будущее.
ѕерейти в начало страницы
 
+÷итировать сообщение
Admin
сообщение 20.8.2009, 12:35
—ообщение #15


јлхимик
»конка группы

√руппа: √лавные јдминистраторы
—ообщений: 5976
–епутаци€: 13
–егистраци€: 5.8.2008
»з: »спани€
ѕользователь є: 1
—пасибо сказали: 4610 раз(а)




ƒл€ построени€ торговой системы, нам необходимо определить используемый ћћ.
ƒл€ расчета торгового лота при тестировании предлагаю использовать оптимальное f. ј начать наше тестирование и формирование обучающей выборки на основе торговли 1 к 1.
—формируем оптимальный сигнал, т.е. фактически сделаем УподгонкуФ, получив идеальный вариант того, какие результаты мы хотим получить от сети:
»сход€ из максимально допустимой просадки 2% от депозита.
ћинимального профита 1%
» максимальной глубиной прогнозировани€ Ц недел€.

ќптимальный сигнал дл€ EUR/USD будет выгл€деть примерно так:


ќптимальный сигнал дл€ GBP/USD будет выгл€деть примерно так:


ќптимальный сигнал дл€ USD/CHF будет выгл€деть примерно так:


ќптимальный сигнал дл€ USD/JPY будет выгл€деть примерно так:


«начение оптимального сигнала по основным четырем валютным парам в CSV формате в ZIP архиве : ѕрикрепленный файл  Optimal_Signal.zip ( 96,44 килобайт )  ол-во скачиваний: 30


--------------------
Ќикто не может вернутьс€ назад, начать все с начала и изменить прошлое, но любой может начать сейчас и изменить будущее.
ѕерейти в начало страницы
 
+÷итировать сообщение
Admin
сообщение 20.8.2009, 12:40
—ообщение #16


јлхимик
»конка группы

√руппа: √лавные јдминистраторы
—ообщений: 5976
–епутаци€: 13
–егистраци€: 5.8.2008
»з: »спани€
ѕользователь є: 1
—пасибо сказали: 4610 раз(а)




ѕродолжение следует wink.gif


--------------------
Ќикто не может вернутьс€ назад, начать все с начала и изменить прошлое, но любой может начать сейчас и изменить будущее.
ѕерейти в начало страницы
 
+÷итировать сообщение
Admin
сообщение 25.8.2009, 22:21
—ообщение #17


јлхимик
»конка группы

√руппа: √лавные јдминистраторы
—ообщений: 5976
–епутаци€: 13
–егистраци€: 5.8.2008
»з: »спани€
ѕользователь є: 1
—пасибо сказали: 4610 раз(а)




по поводу паузы в данной ветке... молчание означает, что работа »ƒ≈“! wink.gif



ƒело в том, что обучение нейронной сети - процесс трудоемкий.

ѕауза обусловлена тем, что в насто€щее врем€ идет обучение сети на четырех валютных парах, с оптимизацией с использованием генетических алгоритмов...

ѕроцесс требует больших вычислительных мощностей и на двухголовом камне 3Ghz может зан€т пару недель (в обще сложности).
ќбучение идет на данных за последние 5 лет. —ерии тестов будут на отрезке в один год со смещением в зону обучени€ глубиной тоже в 1 год.  ак будут результаты - отпишу.


--------------------
Ќикто не может вернутьс€ назад, начать все с начала и изменить прошлое, но любой может начать сейчас и изменить будущее.
ѕерейти в начало страницы
 
+÷итировать сообщение
bess
сообщение 18.1.2010, 7:50
—ообщение #18


Ќовичок
*

√руппа: ѕользователи
—ообщений: 1
–епутаци€: 0
–егистраци€: 17.1.2010
ѕользователь є: 576
—пасибо сказали: 0 раз(а)




ƒоброго времени суток!
я вижу јдмин что ты хорошо разбираешьс€ в принципах работы программы Statistica, сможешь дать пару консультаций по этому поводу?? ј то у мен€ не совсем получаетс€ в ней ув€зать теорию с практикой((
ѕерейти в начало страницы
 
+÷итировать сообщение
Admin
сообщение 20.1.2010, 0:59
—ообщение #19


јлхимик
»конка группы

√руппа: √лавные јдминистраторы
—ообщений: 5976
–епутаци€: 13
–егистраци€: 5.8.2008
»з: »спани€
ѕользователь є: 1
—пасибо сказали: 4610 раз(а)




÷итата(bess @ 18.1.2010, 6:50) *
ƒоброго времени суток!
я вижу јдмин что ты хорошо разбираешьс€ в принципах работы программы Statistica, сможешь дать пару консультаций по этому поводу?? ј то у мен€ не совсем получаетс€ в ней ув€зать теорию с практикой((


Ќе совсем. я изучал в свое врем€ нейросети и защищалси по ним в инсте, но ни в то врем€, ни сейчас дл€ рынкета, € не использовал при расчетах ѕќ Statistica.
— самой программой сталкивалс€ несколько лет назад, и то мельком, помогал установить и настроить своей (тогда еще будущей) жене.
Ќастроил wink.gif
Ѕольше со Statistica не работал. smile.gif


--------------------
Ќикто не может вернутьс€ назад, начать все с начала и изменить прошлое, но любой может начать сейчас и изменить будущее.
ѕерейти в начало страницы
 
+÷итировать сообщение
Admin
сообщение 25.1.2010, 23:51
—ообщение #20


јлхимик
»конка группы

√руппа: √лавные јдминистраторы
—ообщений: 5976
–епутаци€: 13
–егистраци€: 5.8.2008
»з: »спани€
ѕользователь є: 1
—пасибо сказали: 4610 раз(а)




» так, система входа выхода написана. –езультат работы жесткой логики согласно подобранному стилю торговли выгл€дит так:
(ѕара AUDUSD. »спользовались дневные EOD данные. ƒанные полные, включа€ бары субботы и воскресень€)



PS: Ѕольша€ часть изображений в прошлый постах была выложена на сайте iPicture.ru, который ушел в небытие. “.к. € всегда комментировал скриншоты (даже € бы сказал, что скриншоты были дополнением к тесту), то надеюсь, что сейчас и без изображений можно ориентироватьс€ по тексту.


--------------------
Ќикто не может вернутьс€ назад, начать все с начала и изменить прошлое, но любой может начать сейчас и изменить будущее.
ѕерейти в начало страницы
 
+÷итировать сообщение

8 страниц V   1 2 3 > » 
ќтветить в данную темуЌачать новую тему
1 чел. читают эту тему (гостей: 1, скрытых пользователей: 0)
ѕользователей: 0

 



RSS “екстова€ верси€ —ейчас: 18.11.2019, 19:05
ѕолитика конфиденциальности и обработки персональных данных