5.3 Стандарт первого уровня компонента сеть

NetBibl Elements;                                   {Библиотека элементов}

Element Synaps                                      {Обычный синапс}
    InSignals 1                                     {Один входной сигнал}
    OutSignals 1                                    {Один выходной сигнал}
    Parameters 1                                    {Один параметр - вес связи}
    Forw                                            {Начало описания прямого функционирования}
    Begin
                {Вычисление выходного сигнала как произведения входного сигнала на параметр}
        OutSignals[1] = InSignals[1] * Parameters[1]
    End                                             {Конец описания прямого функционирования}
    Back                                            {Начало описания обратного функционирования }
    Begin
                {Вычисление поправки к входному сигналу как произведения поправки к выходному 
                сигналу на параметр}
        Back.InSignals[1] = Back.OutSignals[1] * Parameters[1];
                {Вычисление поправки к параметру как суммы ранее вычисленной поправки к 
                параметру на произведение поправки к обратному  сигналу на входной сигнал}
        Back.Parameters[1] = Back.Parameters[1] + Back.OutSignals[1] * InSignals[1]
    End                                             {Конец описания обратного функционирования}
End Synaps                                          {Конец описания синапса}

Element Branch(N : Long)                            {Точка ветвления на N выходных сигналов}
    InSignals 1                                     {Один входной сигнал}
    OutSignals N                                    {N выходных сигналов}
    Forw                                            {Начало описания прямого функционирования}
        Var Long I;                                 {I - локальная переменная типа 
                                                         длинное целое - индекс}
    Begin
        For I=1 To N Do                             {На каждый из N выходных сигналов}
            OutSignals[I] = InSignals[1]            {передаем входной сигнал}
    End                                             {Конец описания прямого функционирования}
    Back                                            {Начало описания обратного функционирования }
        Var                                         {Описание локальных переменных}
            Long I;                                 {I - длинное целое - индекс}
            Real R;                                 {R - действительное - для накопления суммы}
    Begin
        R = 0;
        For I=1 To N Do                             {Поправка ко входному сигналу равна}
            R = R + Back.OutSignals[I];             {сумме поправок выходных сигналов}
        Back. InSignals[1] = R
    End                                             {Конец описания обратного функционирования}
End Branch                                          {Конец описания точки ветвления}

Element Sum(N Long)                                 {Простой сумматор на N входов}
    InSignals N                                     {N входных сигналов}
    OutSignals 1                                    {Один выходной сигнал}
    Forw                                            {Начало описания прямого функционирования}
        Var                                         {Описание локальных переменных}
            Long I;                                 {I - длинное целое - индекс} 
            Real R;                                 {R - действительное - для накопления суммы}
    Begin
        R = 0;
        For I=1 To N Do                             {Выходной сигнал равен сумме входных}
            R = R + InSignals[I];
        OutSignals[1] = R
    End                                             {Конец описания прямого функционирования}
    Back                                            {Начало описания обратного функционирования}
        Var Long I;                                 {I - локальная переменная типа
                                                         длинное целое - индекс}
    Begin
        For I=1 To N Do                             {Поправка к каждому входному сигналу}
            Back.InSignals[I] = Back.OutSignals[1]  {равна поправке выходного сигнала}
    End                                             {Конец описания обратного функционирования}
End Sum                                             {Конец описания простого сумматора}

Element Mul                                         {Умножитель}
    InSignals 2                                     {Два входных сигнала}
    OutSignals 1                                    {Один выходной сигнал}
    Forw                                            {Начало описания прямого функционирования }
    Begin
                {Выходной сигнал равен произведению входных сигналов}
        OutSignals[1] = InSignals[1] * InSignals[2]
    End                                             {Конец описания прямого функционирования}
    Back                                            {Начало описания обратного функционирования }
    Begin
                {Поправка к каждому входному сигналу равна произведению поправки выходного 
                сигнала на другой входной сигнал}
        Back.InSignals[1] = Back.OutSignals[1] * InSignals[2];
        Back.InSignals[2] = Back.OutSignals[1] * InSignals[1]
    End                                             {Конец описания обратного функционирования}
End Mul                                             {Конец описания умножителя}

Element S_Train                                     {Обучаемый гиперболический сигмоидный элемент}
    InSignals 1                                     {Один входной сигнал}
    OutSignals 1                                    {Один выходной сигнал}
    Parameters 1                                    {Один параметр - характеристика}
    Forw                                            {Начало описания прямого функционирования}
    Begin
                {Выходной сигнал равен отношению входного сигнала к сумме параметра и 
                абсолютной величины входного сигнала}
        OutSignals[1] = InSignals[1] / (Parameters[1] + Abs(InSignals[1])
    End                                             {Конец описания прямого функционирования}
    Back                                            {Начало описания обратного функционирования}
        Var Real R;                                 {R - действительное}
    Begin
                {R - вспомогательная величина для вычисления поправок, равная отношению 
                поправки выходного сигнала к квадрату суммы параметра и абсолютной величины 
                входного сигнала}
        R = Back.OutSignals[1] / Sqr(Parameters[1] + Abs(InSignals[1]);
                {Поправка к входному сигналу равна произведению вспомогательной величины на 
                параметр}
        Back.InSignals[1] = R * Parameters[1];
                {Поправка к параметру равна сумме ранее вычисленной величины поправки и 
                произведения вспомогательной величины на входной сигнал}
        Back.Parameters[1] = Back.Parameters[1] + R * InSignals[1]
    End                                             {Конец описания обратного функционирования}
End S_Train                                         {Конец описания обучаемого гиперболического 
                                                     сигмоидного элемента}

Element S_NotTrain( Char : Real)                    {Не обучаемый гиперболический сигмоидный элемент}
                                                    {Char - характеристика}
    InSignals 1                                     {Один входной сигнал}
    OutSignals 1                                    {Один выходной сигнал}
    Forw                                            {Начало описания прямого функционирования}
    Begin
                {Выходной сигнал равен отношению входного сигнала к сумме характеристики и 
                абсолютной величины входного сигнала}
        OutSignals[1] = InSignals[1] / (Char + Abs(InSignals[1])
    End                                             {Конец описания прямого функционирования}
    Back                                            {Начало описания обратного функционирования}
    Begin
                {Поправка к входному сигналу равна отношению произведения поправки выходного
                сигнала на характеристику к квадрату суммы характеристики и абсолютной 
                величины входного сигнала}
        Back.InSignals[1]  = Back.OutSignals[1] * Char /  Sqr(Char + Abs(InSignals[1]);
    End                                             {Конец описания обратного функционирования}
End S_NotTrain                                      {Конец описания не обучаемого гиперболического
                                                     сигмоидного элемента}

Element Pade(Char : Real)                           {Паде преобразователь Char  - характеристика}
    InSignals 2                                     {Два входных сигнала}
    OutSignals 1                                    {Один выходной сигнал}
    Forw                                            {Начало описания прямого функционирования}
    Begin
                {Выходной сигнал равен отношению первого входного сигнала к сумме 
                характеристики и второго входного сигнала}
        OutSignals[1] = InSignals[1] / (Char+ InSignals[2])
    End                                             {Конец описания прямого функционирования}
    Back                                            {Начало описания обратного функционирования}
        Var Real R;                                 {R - действительное}
    Begin
                {Вспомогательная величина равна поправке к первому входному сигналу - 
                отношению поправки выходного сигнала к сумме характеристики и второго 
                входного сигнала}
        R = Back.OutSignals[1] / (Char + InSignals[2]);
        Back.InSignals[1] = R;
                {Поправка ко второму входному сигналу равна минус отношению произведения
                первого входного сигнала на поправку выходного сигнала к квадрату суммы 
                характеристики и второго входного сигнала}
        Back.InSignals[2] =  -R * OutSignals[1];
    End                                             {Конец описания обратного функционирования}
End Pade                                            {Конец описания Паде преобразователя}

Element Sign_Mirror                                 {Зеркальный пороговый элемент}
    InSignals 1                                     {Один входной сигнал}
    OutSignals 1                                    {Один выходной сигнал}
    Forw                                            {Начало описания прямого функционирования }
    Begin
        If InSignals[1] > 0 Then OutSignals[1] = 1  {Выходной сигнал равен 1, если входной сигнал}
                            Else OutSignals[1] = 0  {больше нуля, и нулю в противном случае}
    End                                             {Конец описания прямого функционирования}
    Back                                            {Начало описания обратного функционирования}
    Begin
        Back.InSignals[1] = OutSignals[1];          {Поправка к входному сигналу 
                                                     равна выходному сигналу}
    End                                             {Конец описания обратного функционирования}
End Sign_Mirror                                     {Конец описания зеркального порогового элемента}

Element Sign_ Easy                                  {Прозрачный  пороговый элемент}
    InSignals 1                                     {Один входной сигнал}
    OutSignals 1                                    {Один выходной сигнал}
    Forw                                            {Начало описания прямого функционирования }
    Begin
        If InSignals[1] > 0 Then OutSignals[1] = 1  {Выходной сигнал равен 1, если входной сигнал}
                            Else OutSignals[1] = 0  {больше нуля, и нулю в противном случае}
    End                                             {Конец описания прямого функционирования}
    Back                                            {Начало описания обратного функционирования}
    Begin
                {Поправка к входному сигналу равна поправке к выходному сигналу}
        Back.InSignals[1] = Back.OutSignals[1];
    End                                             {Конец описания обратного функционирования}
End Sign_Easy                                       {Конец описания прозрачного порогового элемента}

Element Adaptiv_Sum( N : Long)                      {Адаптивный сумматор на N входов}
    InSignals N                                     {N входных сигналов}
    OutSignals 1                                    {Один выходной сигнал}
    Parameters N                                    {N параметров - весов связей}
    Forw                                            {Начало описания прямого функционирования}
        Var                                         {Описание локальных переменных}
            Long I;                                 {I - длинное целое - индекс} 
            Real R;                                 {R - действительное - для накопления суммы}
    Begin
        R = 0;                                      {Выходной сигнал равен скалярному }
        For I=1 To N Do                             {произведению массива входных сигналов}
            R = R + InSignals[I] * Parameters[I];   {на массив параметров}
        OutSignals[1] = R
    End                                             {Конец описания обратного функционирования}
    Back                                            {Начало описания обратного функционирования}
        Var Long I;                                 {I - локальная переменная типа}
    Begin                                           {длинное целое - индекс}
        For I=1 To N Do Begin
                {Поправка к I-у входному сигналу равна сумме ранее вычисленной поправки и 
                произведения поправки выходного сигнала на I-й параметр}
            Back.InSignals[I] = Back.OutSignals[1] * Parameters[I];
                {Поправка к I-у параметру равна произведению поправки выходного сигнала на I-й 
                входной сигнал}
            Back. Parameters[I] = Back. Parameters[I] + Back.OutSignals[1] * InSignals[I]
        End
    End                                             {Конец описания обратного функционирования}
End Adaptiv_Sum                                     {Конец описания адаптивного сумматора}

Element Adaptiv_Sum_Plus ( N : Long)                {Адаптивный неоднородный сумматор на N входов}
    InSignals N                                     {N входных сигналов}
    OutSignals 1                                    {Один выходной сигнал}
    Parameters N+1                                  {N+1 параметр - веса связей}
    Forw                                            {Начало описания прямого функционирования }
        Var                                         {Описание локальных переменных}
            Long I;                                 {I - длинное целое - индекс} 
            Real R;                                 {R - действительное - для накопления суммы}
    Begin
        R = Parameters[N+1];                        {Выходной сигнал равен сумме N+1 параметра}
        For I=1 To N Do                             {и скалярного произведения массива входных}
            R = R + InSignals[I] * Parameters[I];   {сигналов на массив параметров}
        OutSignals[1] = R
    End                                             {Конец описания прямого функционирования}
    Back                                            {Начало описания обратного функционирования }
        Var Long I;                                 {I - локальная переменная типа}
    Begin                                           {длинное целое - индекс}
        For I=1 To N Do Begin
                {Поправка к I-у входному сигналу равна произведению поправки выходного сигнала 
                на I-й параметр}
            Back.InSignals[I] = Back.OutSignals[1] * Parameters[I];
                {Поправка к I-у параметру равна сумме ранее вычисленной поправки и произведения 
                поправки выходного сигнала на I-й входной 
                сигнал}
            Back. Parameters[I] = Back. Parameters[I] + Back.OutSignals[1] * InSignals[I]
        End;
                {Поправка к (N+1)-у параметру равна сумме ранее вычисленной поправки и попраки 
                к выходному сигналу}
        Back.Parameters[N+1] = Back.Parameters[N+1] + Back.OutSignals[1]
    End                                             {Конец описания обратного функционирования}
End Adaptiv_Sum_Plus                                {Конец описания неоднородного 
                                                     адаптивного сумматора}

Element Square_Sum( N : Long)                       {Квадратичный сумматор на N входов}
    InSignals N                                     {N входных сигналов}
    OutSignals 1                                    {Один выходной сигнал}
    Parameters (Sqr(N) + N) Div 2                   {N(N+1)/2 параметров - весов связей}
    Forw                                            {Начало описания прямого функционирования}
        Var                                         {Описание локальных переменных}
            Long I,J,K;                             {I,J,K - переменные типа длинное целое }
            Real R;                                 {R - действительное - для накопления суммы}
    Begin
        K = 1;                                      {K - номер обрабатываемого параметра}
        R = 0;
        For I = 1 To N Do                           {I,J - номера входных сигналов}
            For J = I To N Do Begin
                R = R + InSignals[I] * InSignals[J] * Parameters[K];
                K = K + 1
            End;
                {Выходной сигнал равен сумме всех попарных произведений входных сигналов,
                 умноженных на соответствующие параметры}
        OutSignals[1] = R
    End                                             {Конец описания прямого функционирования}
    Back                                            {Начало описания обратного функционирования }
        Var                                         {Описание локальных переменных}
            Long I, J, K;                           {I,J,K - переменные типа длинное целое }
            Real R;                                 {R - действительное}
            Vector W;                               {Массив для накопления промежуточных величин}
    Begin
        For I = 1 To N Do
            W[I] = 0;
        K = 1;                                      {K - номер обрабатываемого параметра}
        For I = 1 To N Do
            For J = I To N Do Begin
                {Поправка к параметру равна сумме ранее вычисленной поправки и произведения 
                поправки к входному сигналу на произведение сигналов, прошедших через этот 
                параметр при прямом функционировании}
                Back.Parameters[K] = Back.Parameters[K] + 
                    Back.OutSignals[1] * InSignals[I] * InSignals[J];
                R = Back.OutSignals[1] * Parameters[K];
                W[I] = W[I] + R * InSignals[J];
                W[J] = W[J] + R * InSignals[I];
                K = K + 1
            End;
        For I = 1 To N Do
                {Поправка к входному сигналу равна произведению поправки к выходному сигналу 
                на сумму всех параметров, через которые этот сигнал проходил при прямом 
                функционировании, умноженных на другие входные сигналы, так же прошедшие
                через эти параметры при прямом функционировании}
            Back.InSignals[1] = W[I]
    End                                             {Конец описания прямого функционирования}
End Square_Sum                                      {Конец описания квадратичного сумматора}

Element Square_Sum_Plus( N : Long)                  {Адаптивный квадратичный сумматор на N входов}
    InSignals N                                     {N входных сигналов}
    OutSignals 1                                    {Один выходной сигнал}
    Parameters (Sqr(N) + 3 * N) Div 2 + 1           {N(N+3)/2+1 параметров - весов связей}
    Forw                                            {Начало описания прямого функционирования}
        Var                                         {Описание локальных переменных}
            Long I, J, K;                           {I,J,K - переменные типа длинное целое }
            Real R;                                 {R - действительное - для накопления суммы}
    Begin
        K = 2 * N+1;                                {K - номер обрабатываемого параметра}
        R = Parameters[Sqr(N) + 3 * N) Div 2 + 1];
        For I = 1 To N Do Begin
            R = R + InSignals[I] * Parameters[I] + Sqr(InSignals[I]) * Parameters[N + I];
            For J = I + 1 To N Do Begin
                R = R + InSignals[I] * InSignals[J] * Parameters[K];
                K = K + 1
            End
        End
                {Выходной сигнал равен сумме всех попарных произведений входных сигналов,
                умноженных на соответствующие параметры, плюс сумме всех входных сигналов
                умноженных на соответствующие параметры, плюс последний параметр}
        OutSignals[1] = R
    End                                             {Конец описания прямого функционирования}
    Back                                            {Начало описания обратного функционирования }
        Var                                         {Описание локальных переменных}
            Long I, J, K;                           {I,J,K - переменные типа длинное целое }
            Real R;                                 {R - действительное - для накопления суммы}
            Vector W;                               {Массив для накопления промежуточных величин}
    Begin
        For I = 1 To N Do
            W[I] = 0;
        K = 2 * N + 1;                              {K - номер обрабатываемого параметра}
        For I = 1 To N Do Begin
            Back.Parameters[I] = Back.Parameters[I] + Back.OutSignals[1] * InSignals[I];
            Back.Parameters[N + I] = Back.Parameters[N + I] + Back.OutSignals[1] * Sqr(InSignals[I]);
            W[I] = W[I] + Back.OutSignals[1] * (Parameters[I] + 2 * Parameters[N + I] * InSignals[I])
            For J = I + 1 To N Do Begin
                Back.Parameters[K] = Back.Parameters[K] + 
                    Back.OutSignals[1] * InSignals[I] * InSignals[J];
                R = Back.OutSignals[1] * Parameters[K];
                W[I] = W[I] + R * InSignals[J];
                W[J] = W[J] + R * InSignals[I];
                K = K + 1
            End
        End;
        For I = 1 To N Do
            Back.InSignals[1] = W[I]
    End                                             {Конец описания обратного функционирования}
End Square_Sum_Plus                                 {Конец описания адаптивного 
                                                     квадратичного сумматора}

End NetBibl

Function Equal(InSignals, OutSignals : RealArray) : Logic;
    Var Long I;
        Logic L
    Begin
        L = True
        For I = 1 To N Do
            L = L And (InSignals[I] = OutSignals[I]);
        Equal = L
    End

NetBibl SubNets Used Elements; {Библиотека подсетей, использующая библиотеку Elements}

{Сигмоидный нейрон с произвольным сумматором на N входов}
Cascad NSigm(aSum : Block; N : Long; Char : Real)
                {В состав каскада входит произвольный сумматор на N входов и сигмоидный нейрон
                с необучаемой характеристикой}
    Contents aSum(N), S_NotTrain(Char)
    InSignals NumberOf(InSignals, aSum(N))              {Число входных сигналов определяет сумматор}
    OutSignals 1                                        {Один выходной сигнал}
    Parameters NumberOf(Parameters, aSum(N))            {Число параметров определяет сумматор}
    Connections
                {Входные сигналы нейрона - входные сигналы сумматора}
        InSignals[1.. NumberOf(InSignals, aSum(N))] <=> 
            aSum.InSignals[1.. NumberOf(InSignals, aSum(N))]
        aSum.OutSignals <=> S_NotTrain.InSignals        {Выход сумматора - вход преобразователя}
        OutSignals <=> S_NotTrain.OutSignals
                {Параметры нейрона - параметры сумматора }
        Parameters[1.. NumberOf(Parameters, aSum(N))] <=> 
            aSum.Parameters[1.. NumberOf(Parameters, aSum(N))]
End             {Конец описания сигмоидного нейрона с произвольным сумматором}

{Слой сигмоидных нейронов с произвольными сумматорами на N входов}
Layer Lay1(aSum : Block; N,M : Long; Char : Real)
    Contents Sigm: NSigm(aSum,N,Char)[M]                {В состав слоя входит M нейронов}
    InSignals M * NumberOf(InSignals, Sigm)
                {Число входных сигналов определяется как взятое M раз число 
                входных сигналов нейронов. Вместо имени нейрона используем псевдоним}
    OutSignals M                                        {Один выходной сигнал на нейрон}
    Parameters M * NumberOf(Parameters, Sigm)
                {Число параметров определяется как взятое M раз число параметров нейронов}
    Connections
                {Первые NumberOf(InSignals, NSigm(aSum,N,Char)) сигналов первому нейрону, и т.д.}
        InSignals[1..M * NumberOf(InSignals, Sigm)] <=> 
            Sigm[1..M].InSignals[1.. NumberOf(InSignals, Sigm)]
                {Выходные сигналы нейронов - выходные сигналы сети}
        OutSignals[1..M] <=> Sigm[1..M].OutSignals
                {Параметры слоя - параметры нейронов}
        Parameters[1..M * NumberOf(Parameters, Sigm)] <=> 
            Sigm[1..M].Parameters[1.. NumberOf(Parameters, Sigm)]
End             {Конец описания слоя сигмоидных нейронов с произвольным сумматором}

{Слой точек ветвления}
Layer BLay( N,M : Long)
    Contents Branch(N)[M]                               {В состав слоя входит M точек ветвления}
    InSignals M                                         {По одному входному сигналу на точку ветвления}
    OutSignals M * N                                    {N выходных сигналов у каждой точки ветвления}
    Connections
        InSignals[1..M] <=> Branch[1..M].InSignals      {По одному входу на точку ветвления}
                {Выходные сигналы в порядке первый с каждой точки ветвления, затем второй и т.д. }
        OutSignals[1..N * M] <=> Branch[+:1..M].OutSignals[1..N]
End                                                     {Конец описания слоя Точек ветвления}

{Полный слой сигмоидных нейронов с произвольными сумматорами на N входов}
Cascad FullLay(aSum : Block; N,M : Long; Char : Real)
    Contents Br: BLay1(M,N), Ne: Lay1(aSum,N,M,Char)    {Слой точек ветвления и слой нейронов}
    InSignals N                                         {Число входных сигналов - число точек ветвления}
    OutSignals M                                        {Один выходной сигнал на нейрон}
    Parameters NumberOf(Parameters, Ne)
                {Число параметров определяется как взятое M раз число параметров нейронов}
    Connections
        InSignals[1..N]<=> Br.InSignals[1..N]           {Входные сигналы - слою точек ветвления}
                {Выходные сигналы нейронов - выходные сигналы сети}
        OutSignals[1..M] <=> Ne.OutSignals[1..M]
                {Параметры слоя - параметры нейронов}
        Parameters[1..NumberOf(Parameters, Ne)] <=> 
            Ne.Parameters[1.. NumberOf(Parameters, Ne)]
                {Выход слоя точек ветвления - вход слоя нейронов}
        Br.OutSignals[1..N * M] <=> Ne.InSignals[1..N * M]
End             {Конец описания слоя сигмоидных нейронов с произвольным сумматором}

{Сеть с сигмоидными нейронами и произвольными сумматорами, содержащая 
    Input - число нейронов на входном слое;
    Output - число нейронов на выходном слое (число выходных сигналов);
    Hidden - число нейронов на H>0 скрытых слоях;
    N - число входных сигналов
все входные сигналы подаются на все нейроны входного слоя}
Cascad  Net1(aSum : Block; Char : Real; Input, Output, Hidden, H, N : Long)
                {Под тремя разными псевдонимами используется одна и та же подсеть с разными 
                параметрами}
    Contents 
        In: FullLay(aSum,N,Input,Char), 
        Hid1: FullLay(aSum,Input,Hidden,Char)
        Hid2: FullLay(aSum,Hidden,Hidden,Char)[H-1]      {Пусто при H=1}
        Out: FullLay(aSum,Hidden,Output,Char