Классификация сейсмических сигналов на основе нейросетевых технологий

размерность выхода сети. Увеличение нейронов на скрытом слое не приводило к

улучшению результатов, а при уменьшении возникали дополнительные ошибки, в

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

Далее представлены описание параметров настройки программы во входных

файлах и результаты тестирования.

В качестве начальной конфигурации использовались следующие значения

настраиваемых параметров в файле “nvclass.inp”:

TYPE=2_2

NDATA=18

NPATTERN=86

PatternFile=norv18.pat

NetStructure=[18,9,1]

WidrowInit=No

Shuffle=Yes

Scaling=Yes

Eta=0.7

MaxLearnCycles=1950

Loop=5

Результаты экспериментов отражают количество ошибок идентификации от

различных параметров настройки программы.

Для примера рассмотрим влияние процедуры начальной инициализации

весовых коэффициентов и точности обучения на ошибку классификации. На

рисунках 7.1 и 7.2 едставлены эти результаты.

Отметим, что более стабильные результаты получаются в случае

инициализации весов при помощи нормально распределенных величин. Можно

добиться всего лишь 4-5 ошибок из 86, что соответствует ошибке

идентификации равной 5-6 процентов.

Для 9 размерных векторов признаков была использована следующая

структура нейронной сети , т.е. 5 нейронов на скрытом слое было

достаточно для получения хороших результатов.

В качестве примера приведем исследования аналогичные тем, которые

описаны выше.(Рис. 7.3, 7.4).

Последнюю диаграмму можно представить в виде.

Уже сейчас можно сделать вывод, что при использовании не всего набора

признаков идентификации, а некоторой части признаков результаты заметно

улучшаются. Причем для случая 9 –размерных признаков особую роль процедура

начальной инициализации не играет.

Представленные эксперименты не отражают полной картины о возможностях

применения нейронных сетей для идентификации типа сейсмического события, но

они экспериментально подтверждают эффективность нейросетевых технологий для

решения этой задачи.

8. Заключение

Проведенные исследования подтвердили эффективность применения

нейросетевых технологий для идентификации типа источника сейсмических

события. При определенных настройках нейронной сети можно добиться

результатов, когда вероятность правильного распознавания составляет 96.5%.

Ошибки возникают только на 3 векторах из 86. Если сравнивать полученные

результаты с теми, которые можно достичь при использовании стандартных

методов классификации, один из вариантов которых приведен в разделе 4, то

они практически повторяют друг друга. И статистика и нейронные сети

ошибаются одинаковое количество раз, причем на одних и тех же векторах. Из

86 событий статистические методы ошибаются на 3 векторах (1–землетрясение и

2-взрыва), и нейросетевой классификатор также ошибается именно на этих

векторах. Соответственно пока нельзя говорить о каком-то превосходстве

одного метода над другим.

Заметим, что в настоящих исследованиях были использованы довольно общие

и универсальные технологии нейроинформатики (многослойные сети применяются

для решения многих задач, но это не всегда самая оптимальная

нейроструктура), а применение более узких и специализированных нейронных

парадигм в некоторых случаях позволяет получать лучшие результаты. В

частности, при помощи нейропакетов на тех же данных были поставлены ряд

экспериментов над сетями Кохонена, описанными в разделе 5.4. Результаты

показали, что количество ошибок идентификации в большинстве случаев

составляет 3-4 вектора, т.е. практически совпадают с результатами,

полученными на многослойных сетях и классических методах.

Итак, подводя итог всему выше сказанному, выделим основные результаты

проведенных исследований:

1. Нейронные сети позволяют успешно решать проблему определения типа

источника сейсмического события.

2. Новое решение не уступает по эффективности традиционным методам,

использующимся в настоящее время для решения исследуемой задачи.

3. Возможны улучшения технических характеристик нейросетевого решения.

В качестве дальнейших исследований, направленных на повышение

эффективности нейросетевого решения, можно предложить следующие:

. Для многослойных сетей прямого распространения решить проблему начальной

инициализации весовых коэффициентов. Если предположить, что существует

неявная зависимость между матрицей начальных весовых коэффициентов и

конкретной реализацией выборки данных, предназначенной для обучения

нейронной сети, то можно объяснить те случаи, когда результат несколько

хуже, чем в большинстве экспериментов. Возможно, реализация алгоритма

учитывающего распределение исходных данных позволит получать более

стабильные результаты.

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

с большей вероятностью находить глобальный минимум функции ошибки.

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

предназначенной конкретно для решения данной задачи могут привести к

улучшению полученных результатов.

Список литературы.

1. Уоссермен Ф. “Нейрокомпьютерная техника” - М.: Мир,1992.

2. Горбань А.Н., Дубинин-БарковскийВ.Л., Кирдин А.Н. “Нейроинформатика” СП

“Наука” РАН 1998.

3. Горбань А.Н., Россиев Д.А. “Нейронные сети на персональном компьютере”

СП “Наука” РАН 1996.

4. Ежов А.А., Шумский С.А. “Нейрокомпьютинг и его применение в экономике и

бизнесе”.1998.

5. Bishop C.M. “Neural Networks and Pattern Recognition.” Oxford Press.

1995.

6. Goldberg D. “Genetic Algorithms in Machine Learning, Optimization, and

Search.” – Addison-Wesley,1988.

7. Fausett L.V. “Fundamentals of Neural Networks: Architectures, Algorithms

and Applications”, Prentice Hall, 1994.

8. Kohonen T. “Self-organization and Associative Memory”, Berlin: Springer-

Verlag, 1989.

9. Kushnir A.F., Haikin L.M., Troitsky E.V. “Physics of the earth and

planetary interiors” 1998.

10. Копосов А.И., Щербаков И.Б., Кисленко Н.А., Кисленко О.П., Варивода

Ю.В. Отчет по научно-исследовательской работе "Создание аналитического

обзора информационных источников по применению нейронных сетей для задач

газовой технологии"; и др., ВНИИГАЗ, 1995, www.neuralbench.ru

11. Fukunaga K., Kessel D.L., “Estimation of classification error”, IEEE

Trans. Comp. C 20, 136-143. 1971.

12. Деев А.Д., “Применение статистического дискриминационного анализа и его

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

пространства.”, РАН 195, 759-762. 1970.

Приложение.

1. Пример выборки сейсмограмм.

В левом столбце представлены сейсмограммы, описывающие взрывы, а в

правом – землетрясения.

2. Пример файла с векторами признаков.

Представлена выборка из файла 9_Norv.txt, содержащего 9 размерные вектора

признаков.

NumOfPattern: 86

PatternDimens: 9

1 -14.3104 -13.2561 -13.4705 -13.4306 -14.1015 -13.3503 -13.3805

-13.7369 -0.3494 0

2 -14.6881 -13.6349 -12.9050 -13.4323 -14.2279 -13.4720 -13.2117

-13.5791 -1.2801 0

3 -14.4036 -14.1745 -13.8014 -12.7209 -14.6283 -13.9589 -13.4649

-12.9716 -0.8250 0

…

55 -14.3693 -13.4362 -11.4072 -12.3129 -14.8612 -13.3480 -12.8517

-13.4014 -0.7738 0

56 -14.2856 -12.6858 -13.8215 -13.4282 -14.0982 -13.1587 -13.2792

-13.7852 -1.3442 0

57 -14.4822 -13.1141 -13.7787 -13.4466 -13.6761 -13.2969 -13.6033

-13.9252 -0.6642 1

58 -13.5522 -13.1302 -13.5444 -14.1471 -13.2994 -13.2368 -13.9776

-14.4295 -0.9973 1

59 -14.8524 -11.9846 -13.7231 -14.2496 -13.4809 -13.0515 -13.8950

-14.3923 -1.8284 1

…

85 -14.5994 -13.6920 -12.8539 -13.7629 -14.1699 -13.2075 -13.3422

-13.6788 -11.9537 1

86 -14.3821 -13.6093 -12.8677 -13.7788 -14.1260 -13.3246 -13.2966

-13.6453 -11.4304 1

3. Файл с настройками программы

# Common parameters for programm "NVCLASS"

# # # # # # # # # # # # # # # # # # # #

# 1_1 - OnlyTest mode , 1_2 - TestAfterLearn mode,

# 2_1 - CheckOneVector , 2_2 - CrossValidation mode.

TYPE=2_2

NDATA=9

NPATTERN=86

PatternFile=9_Norv.txt

NTEST=10

TestVector=vector.tst

NetworkFile=9.net

ResNetFname=9.net

NumberVector=57

ReportFile=Report.txt

Debug=Yes

# Next parameters was define in result experiments and if you will

# change it, the any characteristics of Neural Net may be not optimal

# (since may be better then optimal).

# # # # # # # # # # #

# 'NetStructure' must be: [NDATA,NUNIT1,1] (NOUT=1 always)

# value 'AUTO'-'NetStructure' will be define the programm.(See help).

# example : [18,9,1], or [18,18,1], or [9,9,5,1]

NetStructure=[18,12,1]

# may be: [Gauss] or [Random]

InitWeigthFunc=Gauss

Constant=3

Alfa=0

Sigma=1.5

Widrow=No

Shuffle=Yes

Scaling=Yes

LearnTolerance=0.1

Eta=1

MaxLearnCycles=50

Loop=3

#end of list

4. Пример файла отчета.

NVCLASS report - Wed Jun 02 15:58:02 1999

Type = 1_2

Neural Net -

PatternFile - vect.txt

Test Vector(s) - vector.tst

ResNetFname - 12.net

LearnTolerance = 0.10

InitialWeigthFunc = Gauss[ 0.0, 1.5]

< Loop 1 >

Learning cycle result:

NumIter = 5

NumLE = 3

Error vector(s): 58, 59, 63,

+-----+------+--------+------+

| N | ID | Result |Target|

+-----+------+--------+------+

| 1 | 24 | 0.1064 | 0 |

| 2 | 25 | 0.9158 | 1 |

| 3 | 26 | 0.0452 | 0 |

| 4 | 27 | 0.0602 | 0 |

| 5 | 28 | 0.0348 | 0 |

| 6 | 29 | 0.0844 | 0 |

| 7 | 30 | 0.1091 | 0 |

| 8 | 31 | 0.0821 | 0 |

| 9 | 32 | 0.0298 | 0 |

| 10 | 33 | 0.2210 | 0 |

+-----+------+--------+------+

< Loop 2 >

Learning cycle result:

NumIter = 5

NumLE = 5

Error vector(s): 33, 34, 55, 58, 63,

+-----+------+--------+------+

| N | ID | Result |Target|

+-----+------+--------+------+

| 1 | 24 | 0.1279 | 0 |

| 2 | 25 | 0.9929 | 1 |

| 3 | 26 | 0.0960 | 0 |

| 4 | 27 | 0.1463 | 0 |

| 5 | 28 | 0.1238 | 0 |

| 6 | 29 | 0.1320 | 0 |

| 7 | 30 | 0.1478 | 0 |

| 8 | 31 | 0.1235 | 0 |

| 9 | 32 | 0.0740 | 0 |

| 10 | 33 | 0.5140 | 1 |

+-----+------+--------+------+

5. Файл описания функций, типов переменных и используемых библиотек

“nvclass.h”.

* --- Neuro classificator---

* Common defines

#include

//#include

#include

#define DefName "nvclass.inp"

#define MAXDEF 100

#define MAXLINE 256

#define NMAXPAT 100

#define NMXINP 20

#define NMXUNIT 20

#define CONT 0

#define EXIT_OK 1

#define EXIT_CNT 2

#define RESTART 911

#define MAXEXP 700 /* Max arg exp(arg) without error 'OVERFLOW'

#define Random 10

#define Gauss 20

#define OK 0

#define Error 1

#define Yes 77

#define No 78

#define Min 0 /* Find_MinMax(...) */

#define Max 1

#define TYPE_ONE 21

#define TYPE_TWO 22

#define TYPE_THREE 23

#define TYPE_FOUR 24

int NDATA = 0;

int NUNIT1 = 0;

int NUNIT2 = 0;

int NUNIT3 = 0;

int NOUT = 1;

int NPATTERN = 0; /* Number of input pattern*/

int NWORK = 0; /* Number of work pattern*/

int NTEST= 0; /* Number of test pattern*/

int result;

int STOP = 0;

int NumOut = 250; /* Number of itteration, after which show result in

debugfile. */

int Num_Iter=10;/* The parameters requred in the procecc of */

float Percent=0.25; /* dinamic lerning with change 'eta' */

float LearnTolerance = 0.10;

float TestTolerance = 0.5;

float MAX_ERR=0.00001; /* min error */

float eta = 1.0; /* learning coefficient*/

float MIN_ETA=0.000001;

float **Array_MinMax;

int *Cur_Number;

float W1[NMXINP][NMXUNIT];

float W2[NMXUNIT];

float PromW1[NMXINP][NMXUNIT];

float PromW2[NMXUNIT];

float PromW1_OLD[NMXINP][NMXUNIT];

float PromW2_OLD[NMXUNIT];

float Err1[NMXUNIT];

float Err2;

float OLD_ERROR;

float GL_Error=0.0;

float Out1[NMXUNIT];

float Out2;

char NetStr[20]="Auto"; /* String with pattern of Net Structure*/

int Type = TYPE_THREE; /* Enter the mode of work of programm */

int InitFunc = Random; /* Random [=10] weigth will RandomDistribution

Gauss [=20] - ... GaussianDistributon */

float Constant = 1; /* RandomDistribution [-Constant,Constant]*/

float Alfa = 0; /* GaussianDistribution [Alfa,Sigma]*/

float Sigma = 1; /* ... */

int Widrow = No; /* Nguyen-Widrow initialization start weigth*/

int Loop = 1; /* Number repeat of Learning cycle */

char *PatternFile; /* File with input patterns*/

char *TestVector;

char *ReportFile="report.txt"; /* name of report file */

char *NetworkFile; /* Name of input NetConfig file */

char *ResNetFname; /* Name of output NetConfig file */

int DEBUG = Yes; /* if 'Yes' then debug info in the DebugFile

char *DebugFile="Logfile.log"; /* Name of the debug file*/

int NumberVector = 0; /* Number of TEST vector */

int Shuffle = Yes; /* Flag - shuffle the input vectors*/

int Scaling = Yes; /* Scaling input vector */

int MaxLearnCycles = 1999; /* Max number of learning iteration */

FILE *Dfp; /* Debug file pointer */

FILE *Rfp; /* Report file pointer*/

typedef struct Pattern {

int ID; /* ID number this vector in all set of pattern */

float *A; /* pattern (vector) A={a[0],a[1],...,a[NDATA]} */

float Target; /* class which this vector is present*/

} PAT;

PAT *Input;

PAT *Work;

PAT *Test;

/* lines in defaults file are in the form "NAME=value" */

typedef struct Default {

char *name; /* name of the default */

char *value; /* value of the default */

} DEF;

/* structure of statistics info about one test vector */

typedef struct Statistic {

int ID; /* Primery number from input file */

float Target;

float TotalRes; /* Total propability */

int Flag; /* Flag = 1, if vector was error and = 0

in over case */

float *result; /* Result of testing vector on current

iteration */

int *TmpFlag; /* analog 'Flag' on current itteration */

int *NumIter; /* Number iteration of learning on which

Learning cycle STOPED */

int **NumLE; /* Error vectors after cycle of learning

was test*/

} STAT;

/* structure of the some result of learning cycle */

typedef struct ResLearning {

int NumIter;

int LearnError[NMAXPAT+1]; /* A[0]-count of error,

A[1]-ID1,

A[2]-ID2,...

A[NMAXRL]-ID?.*/

} RL;

/* function prototypes */

void OnlyTestVector(void);

void TestAfterLearn (void);

void CheckOneVector ( void );

void CrossValidation ( void );

DEF **defbuild(char *filename);

DEF *defread(FILE *fp);

FILE *defopen (char *filename);

char *defvalue(DEF **deflist, const char *name);

int defclose(FILE *fp);

void defdestroy(DEF **, int);

void getvalues(void);

void Debug (char *fmt, ...);

void Report (char *fmt, ...);

void Widrow_Init(void);

int Init_W( void );

float RavnRaspr(float A, float B);

float NormRaspr(float B,float A);

void ShufflePat(int *INP,int Koll_El);

float F_Act(float x);

float Forward (PAT src);

int LearnFunc (void);

int Reset (float ResErr, int Cnt, int N_Err);

void Update_Last (int n, float Total_Out);

void Update_Prom1 (int n);

void Prom_to_W (void);

void Update_All_W (int num, float err_cur );

void Init_PromW(void);

void Prom_to_OLD(void);

int CheckVector(float Res, PAT src);

int *TestLearn(int *src);

RL FurtherLearning(int NumIteration,

float StartLearnTolerans,

float EndLearnTolerans,

RL src);

STAT *definestat (PAT src);

STAT **DefineAllStat (PAT *src,int Num);

void FillStatForm (STAT *st, int iteration, float res, RL lr);

void FillSimpleStatForm (STAT *st, float res);

void destroystat ( STAT *st, int param);

void DestroyAllStat (STAT **st, int Num);

void PrintStatHeader(void);

void printstat(STAT *st);

void PrintStatLearn(RL src);

void PrintTestStat(STAT **st, int len);

void PrintErrorStat (STAT **st,int Len);

int DefineNetStructure (char *ptr);

void getStructure(char buf[20]);

PAT patcpy (PAT dest, PAT src);

PAT* LocPatMemory(int num);

void ReadPattern (PAT *input, char *name,int Len);

void FreePatMemory(PAT* src, int num);

void ShowPattern (char *fname, PAT *src, int len);

void ShowVector(char *fname,PAT src);

float getPatTarget (float res);

PAT* DataOrder (PAT* src,int Len, int Ubit, PAT* dest, PAT* test);

void FindMinMax (PAT *src,int Dimens, int Num_elem, float **Out_Array);

void ConvX_AB_01(PAT src);

int *DefineCN (int len);

int getPosition (int Num, int *src, int Len);

void DestroyCN (int *src);

void ShowCurN (int LEN);

float **LocateMemAMM(void);

void FreeAMM (float **src);

void WriteHeaderNet(char *fname, float **src);

void WriteNet (char *fname,int It);

void ReadHeaderNet(char *fname, float **src);

int ReadNet (char *fname, int It);

FILE *OpenFile(char *name);

int CloseFile(FILE *fp);

/* End of common file */

6. Файл автоматической компиляции программы под Unix -“Makefile”.

CC= cc

LIBS= -lm

OBJ= nvclass.o

nvclass: $(OBJ)

$(CC) -o nvclass $(LIBS) $(OBJ)

nvclass.o: nvclass.c

7. Основной модуль - “nvclass.с”

* Neuron Classificator ver 1.0

#include "common.h"

/* =========================

* MAIN MODULE

* =========================

void main (int argc, char *argv[])

{ int i;

char buf[MAXLINE], PrName[20], *ptr;

time_t tim;

time(&tim);

/* UNIX Module */

Dfp = OpenFile(DebugFile);

strcpy(buf,argv[0]);

ptr = strrchr(buf,'/');

ptr++;

strcpy(PrName,ptr);

Debug ("\n\n'%s' - Started %s",PrName,ctime(&tim));

getvalues();

Rfp = OpenFile(ReportFile);

DefineNetStructure(NetStr); /* NetStr string from input file */

getStructure(buf);

Debug ("\nNeyral net %s",buf);

Input = LocPatMemory(NPATTERN);

Work = LocPatMemory(NPATTERN);

Array_MinMax = LocateMemAMM();

Cur_Number = DefineCN (NPATTERN);

printf("\nMetka - 1");

if (Type == TYPE_ONE)

OnlyTestVector ();

if (Type == TYPE_TWO)

TestAfterLearn ();

if (Type == TYPE_THREE)

CheckOneVector ();

if (Type == TYPE_FOUR)

CrossValidation();

time(&tim);

Debug ("\n\n%s - Normal Stoped %s",PrName,ctime(&tim));

CloseFile(Dfp);

CloseFile(Rfp);

FreeAMM (Array_MinMax);

DestroyCN (Cur_Number);

FreePatMemory(Input,NPATTERN);

FreePatMemory(Work, NPATTERN);

}

* ^OnlyTestVectors - read net from (NetworkFile) and test the

TestVector(s)

void OnlyTestVector(void)

{ char buf[MAXLINE+1];

STAT **st, *stat;

int i,j;

float Res;

Debug ("\nOnlyTestVector proc start");

Debug ("\n NPATTERN = %d",NPATTERN);

Debug ("\n NTEST = %d",NTEST);

Test = LocPatMemory(NTEST);

ReadPattern(Test,TestVector, NTEST);

/* ShowPattern ("1.tst",Test,NTEST);*/

PrintStatHeader();

st = DefineAllStat (Test,NTEST);

ReadHeaderNet(NetworkFile,Array_MinMax);

if (Scaling == Yes)

{ for (i=0;i ",i+1);

ReadNet(NetworkFile,i+1);

for (j=0;j x/32768

* -> x from [0,1]

float RavnRaspr(float A, float B)

{float x;

x = (B-A)*rand()/(RAND_MAX+1.0) + A;

return x;

}

float NormRaspr(float A,float B)

{ float mat_ogidanie=A, Sigma=B;

float Sumx=0.0, x;

int i;

for (i=0;i N[a,sigma]*/

x = Sigma*(Sumx-6) + mat_ogidanie;

return x;

}

int Init_W ( void )

{ int i,j;

float A, B;

time_t t,t1;

t = time(NULL);

t1=t;

/* restart random generator*/

while (t==t1)

srand((unsigned) time(&t));

if (InitFunc == Random)

{ A = -Constant;

B = Constant;

Debug ("\nInit_W () --- Start (%ld))",t);

Debug ("\n InitFunc=Random[%4.2f,%4.2f]",A,B);

for(i=0; i LearnTolerance)

{ NumErr++;

Init_PromW();

Update_Last(K, Res);

Update_Prom1(K);

Prom_to_W();

}

err_cur = err_cur + (ep[n]*ep[n]);

}

err_cur=0.5*(err_cur/NWORK);

result = Reset(err_cur, num, NumErr);

if ((num % NumOut)==0)

Debug("\nStep :%d NumErr :%d Error:%6.4f",num,NumErr,err_cur);

} while (result == CONT || result == RESTART);

Debug("\nStep :%d NumErr :%d Error:%6.4f",num,NumErr,err_cur);

return num;

}

-----------------------

w11

8A. 1.3. 2CEA;>9=K9 ?5@A5?B@>=.

8A. 1.2. 5@540B>G=K5 DC=:F88 =59@>=>2.

(

y=f(s)

8A. 1.1. 0B5=

f(x)

w12

w3p

w40

vРис. 1.3. Двухслойный персептрон.

Рис. 1.2. Передаточные функции нейронов.

(

y=f(s)

Рис. 1.1. Математический нейрон

f(x)

w12

w3p

w40

Рис 1.4. Этапы нейросетевого решения задачи.

Рис 1.5. Процесс обучения нейронной сети.

Рис 1.6. Задача прогнозирования.

Рис 1.7. Задача распознавания.

Рис 1.8. Задача распознавания.

[pic]

Рис 1.9. Применение нейросетей для отыскания зависимостей переменных

Рис 1.10. Задача кластеризации.

Сейсмограмма

Решающее

правило

Землетрясение

Взрыв

Рис. 2.1. Постановка задачи классификации сейсмических сигналов.

Рис.3.1. Пример сейсмограммы.

Рис. 4.1. Одиночный нейрон

y=f(x)

(

[pic]

Рис. 4.2. Линейный дискриминатор.

Рис 4.3. Сети Ворда

Рис.4.4 Сеть Кохонена.

[pic]

Рис.4.5 Сеть Кохонена для классификации сейсмических сигналов.

[pic]

Рис 5.1. Гистограмма значений переменной при наличии редких, но больших по

амплитуде отклонений от среднего.

[pic]

Рис 5.2. Нелинейная нормировка, использующая логистическую функцию

активации [pic]

[pic]

Рис 5.3. Автоассоциативная сеть с узким горлом – аналог правила обучения

Ойя.

[pic]

Рис 5.4. Слой линейных нейронов

Рис. 6.1. Двухслойный персептрон.

(

z0(1

x0(1

w10

wH0

wHp

f(x)

Рис. 6.2. Единичная сигмоида, со значениями в диапазоне (0,1).

Ошибка обучения

Ошибка на тестовом наборе

Рис 6.3 Ранняя остановка обучения в момент минимума ошибки валидации.

[pic]

Рис. 7.1 Инициализация весовых коэффициентов случайным образом из интервала

[-a,a].

[pic]

Рис. 7.2. Инициализация весовых коэффициентов с помощью нормального

распределения с параметрами N[-(,(].

[pic]

Рис. 7.3. Инициализация весовых коэффициентов случайным образом из

интервала [-a,a].

[pic]

Рис 7.4. Инициализация весовых коэффициентов с помощью нормального

распределения с параметрами N[-(,(].

[pic]

Страницы: 1, 2, 3, 4, 5, 6

МЕНЮ

Классификация сейсмических сигналов на основе нейросетевых технологий

ИНТЕРЕСНОЕ