تم حل شيفرة إكسبيرت الشبكات العصبيه

[kasper]

لو عدلنا اكسبرت يعطي نتائج جيدة بحيث انة يعتمد على نتائج سابقة مخزنة في قاعدة بيانات بحيث يكون في قاعدة البينات :::

8 الاف صفقة ناجحة مع معطيات المؤشرات وقتها
الفين صفقة خاسرة مع معطيات المؤشرات وقتها

بحيث يقوم برنامج الشبكة العصبية او الاكسبرت نفسة عند توفر شروط دخول الصفقة بالبحث في قاعدة البينات عن شروط مشابهه اذا كانت ناجحة او لا

بحيث انة اذا كانت ناجحة سابقا يقوم بالدخول فيها
اذا كانت خسرانة سابقا يمتنع عن الدخول فيها
اذا كانت شروط الصفقة لم تحدث من قبل وغير متوفرة بالقاعدة يقوم بتنفيذها وتسجيل نتيجتها بالقاعدة وبكذا يتعلم الاكسبرت ويعمل على تحقيق ارباح في نفس الوقت

انا مبرمج php و mysql واتوقع mql سهلة لاكن العقبة هي كوني مبتديء في الفوركس

[سمير صيام]

تحية اجلال وتقدير لك ولاخونا ابو الطيب

[DO_LAR]

لو عدلنا اكسبرت يعطي نتائج جيدة بحيث انة يعتمد على نتائج سابقة مخزنة في قاعدة بيانات بحيث يكون في قاعدة البينات :::

8 الاف صفقة ناجحة مع معطيات المؤشرات وقتها
الفين صفقة خاسرة مع معطيات المؤشرات وقتها

بحيث يقوم برنامج الشبكة العصبية او الاكسبرت نفسة عند توفر شروط دخول الصفقة بالبحث في قاعدة البينات عن شروط مشابهه اذا كانت ناجحة او لا

بحيث انة اذا كانت ناجحة سابقا يقوم بالدخول فيها
اذا كانت خسرانة سابقا يمتنع عن الدخول فيها
اذا كانت شروط الصفقة لم تحدث من قبل وغير متوفرة بالقاعدة يقوم بتنفيذها وتسجيل نتيجتها بالقاعدة وبكذا يتعلم الاكسبرت ويعمل على تحقيق ارباح في نفس الوقت

انا مبرمج php و mysql واتوقع mql سهلة لاكن العقبة هي كوني مبتديء في الفوركس

اهلا اخي الكريم ,,
على حسب مافهمت ان الشبكة العصبية هي تقوم ماتقوم به قاعدة البيانات ولكن تأخذ المعطيات من الشارت نفسه في نفس الوقت وبسرعة فائقة وهي بمثابة الفلتر للصفقات وايضا الميزة في الشبكة انها صغيرة الحجم .

ثانيا فكرتك رائعة جدا وانا سبق وان طرحتها على اخونا المبرمج trider ولكن لم يرد علي في هذا الموضوع وبما اني لاأملك العلم في البرمجة لااستطيع ان اعمل شي ولكن الفكرة ستكون ناجحة لأنه سيكون إكسبيرت ذكي لأنه يجمع شروط لإنجاح الصفقة بطريقة لايمكن ان تجمع في ملف اكسبيرت .
لكن الاخ تريدر قام بفكرة مبدئية قريبة من هذه وجديدة لم اراها في اكسبيرت سابقا وصمم اكسبيرت فيه خيارات لتجربة الاهداف والوقف وعند عمل باك تست يظهرلك كتابة على الشارت بعدد الصفقات السابقة الرابحة والخاسرة بالأعدادات التي وضعتها طبعا على ماأذكر اختار تقاطع الموفينق افرج للإستراتيجية الاكسبيرت المستخدم , لكن يفترض منه ان يكمل تطوير الاكسبيرت بحفظ هذه البيانات والشروط التي تم الدخول بها في كل صفقة و ان يضيف الشروط المرتبطة بين الصفقات الخاسرة كعامل مشترك لتحليل واستخراج العامل بين الصفقات الخاسرة مثلا التوقيت ومعدل الحركة اليومي وعلاقة العملات بين بعضها في حركتها هل هي مع بعضها او متعاكسة الحركة وايضا من هذه الشروط التي تعطي الاكسبيرت عوامل مهمة في حركة السعر لإيجاد سبب مشترك يتكرر في الصفقات الخاسرة لتسجيلة وتجنبه في المتاجرة المستقبلية .
وان شاءالله ناوي اتعلم هذه اللغة لأصيغ بعض الأفكار التي تراودني لصنع إكسبيرت ناجح
لكن ايضا تخصص برمجة الشبكات العصبية يدخل في مرحلة متقدمة في البرمجة لأن على ماقرأت لكل لغة برمجية منهج في برمجة الشبكات العصبية ولم أرى في المنتديات العربية المتخصصة في البرمجة مبرمج محترف لصنع هذه الشبكات لاأدري هل هو علم معقد زيادة على تعقيد البرمجة أم انه لايعتمد عليه في مشاريع البرمجة المتعارف عليها . ولاأدري هل له تخصص لوحدة في الجامعات لأني لم أرى في مناهج علم الحاسب والبرمجة في الجامعات انهم يدرسون هذا التخصص .

خلاصة الكلام , اذا كنت مستعد لعمل قاعدة البيانات وعندك الوقت وتريد فريق عمل فلنتعاون على ذلك ونفتح موضوع لهذا المشروع البرمجي لأنه مختلف عن موضوعنا هنا وايضا ليتم ترتيب الأفكار وتقسيم المهمات على كل شخص يريد المشاركة في هذا الموضوع.
, وشكرا على مبادرتك وطرحك للفكرة .

[domdom]

أخي kasper إن شاء الله سألقي نظرة على الاكسبيرت الذي إقترحته و يا رب يكون فاتحة خير
أشكرك أخي الكريم

أستاذ سمير نورت الموضوع وانا شاكر ردك الطيب و كل التحية و التقدير لك لما تبذله في خدمة هذا المنتدى
أشكرك أخي الحبيب

أخي DO$LAR أنا معك أنت و جميع الاخوة حتى النهاية حتى نصل لشيء يرضي الجميع
إن شاء الله

بارك الله بكم جميعا إخوتي الكرام

[Alertpay]

لو عدلنا اكسبرت يعطي نتائج جيدة بحيث انة يعتمد على نتائج سابقة مخزنة في قاعدة بيانات بحيث يكون في قاعدة البينات :::

8 الاف صفقة ناجحة مع معطيات المؤشرات وقتها
الفين صفقة خاسرة مع معطيات المؤشرات وقتها

بحيث يقوم برنامج الشبكة العصبية او الاكسبرت نفسة عند توفر شروط دخول الصفقة بالبحث في قاعدة البينات عن شروط مشابهه اذا كانت ناجحة او لا

بحيث انة اذا كانت ناجحة سابقا يقوم بالدخول فيها
اذا كانت خسرانة سابقا يمتنع عن الدخول فيها
اذا كانت شروط الصفقة لم تحدث من قبل وغير متوفرة بالقاعدة يقوم بتنفيذها وتسجيل نتيجتها بالقاعدة وبكذا يتعلم الاكسبرت ويعمل على تحقيق ارباح في نفس الوقت

انا مبرمج php و mysql واتوقع mql سهلة لاكن العقبة هي كوني مبتديء في الفوركس

فكره رائعه لو عملناها لكن المشكله كيف حنعرف أن الشروط متشابهه ونخزنها بقاعدة
البيانات؟؟؟؟؟؟
ما هي البيانات اللتخزنها شبكة Domdom ؟

[mercury_man]

طيعا مشكورين على هذا الجهد الكبير
لكن هل متاكدين انها شبكة عصبية قابلة للتعلم
لانه يبدو لي انها اوزان لشبكة عصبية تم تعليمها مسبقا وما هذه الا الاوزان لاكسبيرت محدد ولا يمكن تركيبها لاكسبيرت اخر
ارجو ان اكون مخطئا
لو هناك احد لمس نتائج التدريب او الطريقة ينورنا الله ينور عليكم جميعا.

[bolbol911]

أحبتي في الله
والله منذ مدة لم أجد موضوعا عميقا بهذا العمق
أتمنى أن يثمن الموضوع ...ويعاد تفعيله
وجزا الله أستاذنا دمدم خير الجزاء على جميل صنيعه

[أبو الدرداء]

هل الأخ دوم دوم ما زال يدخل المنتدى

[n.forex]

بعض أنواع الشبكات العصبيه:


1-- Feedforward neural networks

[n.forex]

c-code

Feedforward Neural Networks

part1

  /*------------------------------*
*                               *
* Code listing PNET.HPP         *
*                               *
*-------------------------------*
#define    NEURONHIGH   1.0           // Neuron's high output value
#define    NEURONLOW    0.0           // Neuron's low output value
#define    TRUE         1
#define    FALSE        0

class      WEIGHT                     // Forward reference

struct     WEIGHTIMAGE {
double     data;                      // Weight value
int        sneuron;                   // Source neuron for this weight
int        dneuron;                   // Dest neuron for this weight
WEIGHTIMAGE *next;
};

struct NETRESULTS {
int        index;                     // Neurons identification number
double     value;                     // Neurons output value
char       character;                 // char representation of digit
};

class NETFILEDATA {
private:
 double    temperature;                // Neurons temperature
 double    threshold;                  // Neurons firing threshold
 int       Nlayers;                    // Number of layers in the net
 int       neurons[MAXLAYERS];         // Number of neurons per layer
 int       status;                     // Error status (0 = OK)
 WEIGHTIMAGE *weights[MAXLAYERS - 1 ]; //Temp weight storage area
 void      ADDweights(int 1, int d, int s, double w);
 double    GETweights(int 1, int d, int s);

public:
NETFILEDATA(void);
int SetupNet(char *);
double GetTemp(void) { return temperature; }
double GetThresh(void) { return threshold; }
int GetNlayers(void) { return Nlayers; }
int GetLayerSize(int layer) { return neurons[layer]; }
double GetWeight(int 1, int d, int s) { return GETweights(1-1, d, s); }
int GetStatus(void) { return status; }
};

part2

 //**********************************************************
//  THE NEURON CLASS                                       *
//**********************************************************
class NEURON {
private:
 static double temperature;     //Holds a single copy for all neurons
 static double threshold;       // Holds a single copy for all the neurons
 int           id;              // Holds a neuron identification number
 double        out;             // Holds a neurons output value
 WEIGHT        *weight1;        // Pointer to list of weights (head)
 WEIGHT        *weightL;        // Pointer to list of weights (tail)
 int           BiasFlg;         // 1 = Bias Neuron, 0 otherwise
 NEURON *next;                  // Hook to allow neurons to be list members

public:
 NEURON(void) { id = 0; out = 0;
         weight1 = (WEIGHT *)NULL; next = (NEURON *)NULL;}
 NEURON(int ident, int bias=0) { id = ident; out = 0; BiasFlg=bias;
         weight1 = (WEIGHT *)NULL; next = (NEURON *)NULL; }
 void calc(void);               // Update out based on weights/inputs
 void SetNext(NEURON *N) { next = N;}
 NEURON *GetNext(void) { return next;}
 void SetWeight(double Wght, NEURON *SrcPtr);
 int Getld(void) { return id; }
 double GetOut(void) { return out;}
 void SetTemperature(double tmpr) { temperature = tmpr; }
 void SetThreshold(double thrsh) { threshold = thrsh; }
 void SetOut(double val) { out = val; }
 int lsBias(){return BiasFlg;}
};
double NEURON::temperature = 0.0;     // REQUIRED for static data elements
double NEURON::threshold = 0.0;

//************************************
//  THE WEIGHT CLASS                 *
//************************************

class WEIGHT {
private:
 NEURON *SRCneuron;                // Source neuron for this weight
 double WtVal;                     // Magnitude of weight
 WEIGHT *next;                     // Hook so weights can be list members
public:
 WEIGHT(double W, NEURON *SN) { next = (WEIGHT *)NULL;
                SRCneuron = SN; WtVal = W; }
 NEURON *GetSRCNeuron(void) { return SRCneuron; }
 double getWeight(void) { return WtVal; }
 void SetNext(WEIGHT *W) { next = W; }
 WEIGHT *GetNext(void) { return next; }
};

part3

  //************************************
//   THE LAYER CLASS                 *
//************************************

class LAYER {
private:
  int         Layer ID;            // 0 for input, 1 for 1st hidden,...
 unsigned int Ncount;              // # of neurons in layer;
 NEURON       *Neuron1;            // Pointer to 1st neuron in layer
 NEURON       *NeuronL;            // Pointer to last neuron in layer
 LAYER        *next;               // Hook so layers can be list members

public:
 LAYER(int layer_id, NETFILEDATA *netdata);
 int SetWeights(NEURON *PrevNeuron, NETFILEDATA *netdata);
 void SetNext(LAYER *Nlayer) { next = Nlayer; }
 int GetLayerID(void) { return LayerID; }
 NEURON *GetFirstNeuron() { return Neuron1; }
 LAYER *GetNext(void) {return next;}
 unsigned int getCount(void) { return Ncount; }
 void calc(int);
};

//*********************************************
// THE NETWORK CLASS                          *
//*********************************************

class NETWORK {
private:
 int           Alive;               // True when weights are valid
 NETFILEDATA   netdata;             // Class to load saved weights
 int           Nlayers;             // Number of layers in the network
 LAYER         *INlayer;            // Pointer to the input layer
 LAYER         *OUTlayer;           // Pointer to the output layer
 NETWORK       *next;               // Need more than 1 network ... OK

public:
 NETWORK(void) { Alive = 0; next=(NETWORK *)NULL; }
 int Setup(char *);
 void ApplyVector(unsigned char *, int);
 void RunNetwork(void);
 int RequestNthOutNeuron(int, NETRESULTS *);
 double RequestTemp(void);
 double RequestThresh(void);
 int RequestLayerSize(int);
 int GetAlive() { return Alive; }
 NETWORK *GetNext() {return next;}
 void SetNext(NETWORK *netptr) {next=netptr;}
private:
 int SetWeights(void);
};

[n.forex]

2--Linear Associative Memory LAM

c-code

 /*************************************************
*                                                *
* LAM                                            *
*                                                *
**************************************************

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <math.h>

//FUNCTION PROTOTYPES

//void ShowResults(int, long int,double temp, double alpha, double eta);

//DEFINES
#define MAXNEURONS 100   //MAX NUMBER OF NEURONS PER LAYER
#define MAXPATTERNS 80   //MAX NUMBER OF PATTERNS IN A TRAINING SET

class LAME
{

private:
 int W[MAXNEURONS][MAXNEURONS];         //WEIGHTS MATRIX
 int Thresh[MAXNEURONS];
 int TrnSet[MAXPATTERNS][MAXNEURONS];   //TRAINING SET
 int TstSet[MAXPATTERNS][MAXNEURONS];   //TRAINING SET
 int inVect[MAXNEURONS];
 int outVect[MAXNEURONS];
 int  Neurons;
 int  TrnPatterns;                //# of training set patterns
 int  TstPatterns;                //# of test set patterns
public:
 LAME(void);
 void GetTrnSet(char*Fname);
 int GetTstSet(char *Fname);
 void Train();
 void Run(int i);
 void ShowWeights();
 void ShowThresholds();
 void ShowInVect();
 void ShowOutVect(); 
};

//__________________________________________________________________
//METHOD DEFINITIONS

LAME::LAME(){
Neurons=0;
TrnPatterns=0;
TstPatterns=0;
}

void LAME::GetTrnSet(char*Fname){
FILE *PFILE;
int i,j,k;

PFILE = fopen(Fname,"r");          //batch
if (PFILE==NULL){
 printf("\nUnable to open file %s\n", Fname);
 exit(0);
 }
fscanf(PFILE,"%d",&TrnPatterns);
fscanf(PFILE,"%d",&Neurons);
for (i=0; i<TrnPatterns; i++) {
 for (j=0; j<Neurons; j++) {
   fscanf(PFILE,"%d",&k);
   TrnSet[i][j]=k;
   }/* endfor */
 }/* endfor */
}

int LAME::GetTstSet(char *Fname){
 FILE *PFILE;
 int i,j,k;
PFILE - fopen(Fname,"r");          //batch
if (PFILE==NULL){
 printf("\nUnable to open file %s\n", Fname);
 exit(0);
 }
fscanf(PFILE,"%d", &TstPatterns);
for (i=0; i<TstPatterns; i++) {
 for (j=0; j<Neurons; j++) {
   fscanf(PFILE,"%d",&k);
   TstSet[i][j]=k;
   }/* endfor */
 }/* endfor */
return(TstPatterns);
}

void LAME::Train(){
 int i,j,p;
//Calc weight matrix

for (i=0; i<Neurons; i++) {
 for (j=0; j<Neurons; j++) {
   W[i][j]=0;
  for (p-0; p<TrnPatterns; p++) {
    W[i][j] += (2*TrnSet[p][i]-1) *(2*TrnSet[p][j]-1);
    }/* endfor */
  }/* endfor */
 }/* endfor */

//Calc Thresholds
for (i=0; i<Neurons; i++) {
 for (j=0; j<Neurons; j++) {
   Thresh[i] += W[i][j];
   }/* endfor */
 Thresh[i]=Thresh[i]/2;
 }/* endfor */
}

void LAME::Run(int tp){
 int i,j;
 int RawOutVect[MAXNEURONS];
for (i=0; i<Neurons; i++) {
 inVect[i]=TstSet[tp][i];
 }/* endfor */
for (i=0; i<Neurons; i++) {
  RawOutVect[i] = 0;
  for (j=0; j<Neurons; j++) {
    RawOutVect[i]+=W[i][j] * inVect[j];     //Calc Raw output vect
    }/* endfor */
  }/* endfor */
//apply threshold

for (i=0; i<Neurons; i++) {
 if (RawOutVect[i]>Thresh[i]) {
    outVect[i]=1;
 } else {
    outVect[i]=0;
 }/* endif */
 }/* endfor */

}
void LAME::ShowWeights(){
 int i,j;
for (i=0; i<Neurons; i++) {
 for (j=0; j<Neurons; j++) {
   printf("%d ",W[i][j]);
   }/* endfor */
 printf("\n");
 }/* endfor */
}

void LAME::ShowThresholds(){
 int i;
for (i=0; i<Neurons; i++) {
 printf("%d ",Thresh[i]);
 }/* endfor */
printf("\n");
}

void LAME::ShowInVect(){
 int i;
printf("lN: ");
for (i=0; i<Neurons; i++) {
 printf("%d ",inVect[i]);
 }/* endfor */
printf("\n");
}

void LAME::ShowOutVect(){
 int i;
printf("OUT: ");
for (i=0; i<Neurons; i++) {
 printf("%d ",outVect[i]);
 }/* endfor */
printf("\n");
}

//__________________________________________________________________

LAME LAM;

/************************************************
*
*  MAIN                                         *
*************************************************
/

int main(int argc, char *argv[])
{
 int TstSetSize;
 int i;
if (argc>2) {
 LAM.GetTrnSet(argv[1]);
 TstSetSize=LAM.GetTstSet(argv[2]);
 LAM.Train();
 LAM.ShowWeights();
 for (i=0; i<TstSetSize; i++) {
   LAM.Run(i);                          //Evaluate ith test pattern
   printf("\n");
   LAM.ShowInVect();
   LAM.ShowOutVect();
 }/* endfor */
 }
else {
 printf("USAGE: LAM TRAINING_FILE TEST_FILE\n");
 exit(0);
 }

return 0;
}

[n.forex]

3-Hopfield Networks

c-code

  /************************************************
*                                               *
* Binary Hopfield Network                       *
*                                               *
*************************************************/

#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
//#include <dos.h>

//__________________________________________________________________

//DEFINES
#define MAXNEURONS   64
#define MAXPATTERNS  10
#define MAXITER  600000
#define TRUE    1
#define FALSE   0

//__________________________________________________________________

//FUNCTION PROTOTYPES
//network fns
void InitNetRand(void);              //Scramble net state
void LoadTrainingSet(char *Fname);   //Get training set from file
void TrainNet();                     //Train net to recognize patterns
void RunNet(void);                   //Update net til convergence or MAXITER
int UpdateNeuron(int j);             //Update jTH neuron
                                     //Return TRUE if state changed
void LoadUserPattern(char *Fname);
int QueryAllClean(void);             //Return TRUE if all neurons were visited
void SetAllToDirty(void);            //Set all neurons to NOT visited
//utility fns
void Initialize(int cnt, char *Name);   //housekeeping
void DisplayPatVect(int V[MAXNEURONS]); //show Net/Pattern (human-eye view)
void SavePatVect(int V[MAXNEURONS],     //store Net/Pattern (human-eye view)
           char *txt, int i);           //to the archive file
void DisplayWeights(void);              //show the weight matrix
void DisplayPatterns(void);             //Display all trained patterns
int QueryUserInt(char *msg);
void KeyWait(void);
void KeyWait2(char*txt);
int random(int N);
//__________________________________________________________________

//GLOBALS
int PatVec[MAXNEURONS];                //Pattern Vector
int PatMatrix[MAXPATTERNS][MAXNEURONS];//Pattern Vector
int NEURON[MAXNEURONS];                //Network
int T[MAXNEURONS][MAXNEURONS];         //Weight matrix
int NumNeurons;                        //Actual size of net
int NumPatterns;                       //Actual number of patterns
int PatternX;                          //X-dimension for human viewing
int PatternY;                          //Y-dimension for human viewing
int Dirty[MAXNEURONS];                 //TRUE if neuron has not been
                                         updated
                                       //FALSE otherwise

FILE *ARCHIVE;

//__________________________________________________________________

int random(int N){
int x;
x=N*rand();
return (x/RAND_MAX);
}

void DisplayPatVect(int V[MAXNEURONS]){
 int x,y,indx;

indx=0;
for (y=0; y<PatternY; y++) {
  for (x=0; x<PatternX; x++) {
   if (V[indx]==1) {
      printf("X");
   } else {
       printf(".");
     }/* endif */
     indx++;
     }/* endfor */
   printf("\");
   }/* endfor */
  printf("\n");
}

void SavePatVect(int V[MAXNEURONS], char*txt, int i) {
 int x,y,indx;
 indx=0;
 fprintf(ARC H IV E,"\n");
 for (y=0; y<PatternY; y++) {
  for (x=0; x<PatternX; x++) {
    if (V[indx]==1){
      fprintf(ARCHIVE,"X");
    } else {
      fprintf(ARCHIVE,".");
    }/* endif */
    indx++;
    }/* endfor */
  fprintf(ARCHIVE,"\n");
  }/* endfor */ fprintf(ARCHIVE,"\n%s ",txt);
  if (i>=0) fprintf(ARCHIVE,"%d ",i);
  fprintf(ARCHIVE,"\n\n ");
}

void DisplayWeights(){
 int i,j;
fprintf(ARCHIVE,"WEIGHTS:\n");
for (i=0; i<NumNeurons; i++) {
  fprintf(ARCHIVE,"[");
  for (j=0; j<NumNeurons; j++) {
    fprintf(ARCHIVE, "%d",T[j][i]);
    }/* endfor */
  fprintf(ARCHIVE,"]\n");
  }/* endfor */
}

void DisplayPatterns() {
 int i,p;
for (p=0; p<NumPatterns; p++) {
 for (i=0; i<NumNeurons; i++) {
   PatVec[i] =PatMatrix[p][i];
   }/* endfor */
 DisplayPatVect(PatVec);                 //show 1st training pattern
 SavePatVect(PatVec, "Training Pattern", p+1);
 printf("\n\nTraining Pattern %d of %d\n\n",p+1,NumPatterns);
 KeyWait();
 }/* endfor */
}

int QueryUserInt(char *msg){
int rv;
printf("Enter %s ==> ",msg);
scanf("%d",&rv);
return rv;
}

void KeyWait(void){
printf("Press any key to continue.\n");
while (!kbhit()) { }/* endwhile */
getch();
}

void KeyWait2(char *txt){
printf("\n\n%s\n",txt);
KeyWait();
}

void InitNetRand() {
 int i,r;

fprintf(ARCHIVE,"Creating test pattern\n");
srand(5);
//randomize();

for (i=0; i<NumNeurons; i++) {
 r=random(100);
 if (r >= 50) {
  NEURON[i]=0;
  }
 else {
  NEURON[i]=1;
  }/* endif */
 }/* endfor */

}

void LoadTrainingSet(char*Fname) {
 int pat,j, InVal;
 FILE *PATTERNFILE;

printf("Loading training set from default file: %s\n", Fname);
fprintf(ARCHIVE,"Loading training set from default file: %s\n",Fname);
PATTERNFILE = fopen(Fname,"r");
if (PATTERNFILE==NULL){
 printf("Unable to open default training Set file: %s",Fname);
 exit(0);
 }

//printf("\n");
fscanf(PATTERNFILE,"%d",&NumNeurons);     //Get number of neurons
fscanf(PATTERNFILE,"%d",&NumPatterns);    //Get number of patterns
fscanf(PATTERNFILE,"%d",&PatternX);       //X-dimension for human viewing
fscanf(PATTERNFILE,"%d",&PatternY);       //Y-dimension for human viewing
printf("%d Patterns Loaded\n",NumPatterns);
fprintf(ARCHIVE,"%d Patterns Loaded\n",NumPatterns);
for (pat=0; pat<NumPatterns; pat++) {
  for (j=0; j<NumNeurons; j++) {
    fscanf(PATTERNFILE,"%d",&InVal);
    PatMatrix[pat][j]=InVal;
    }//endfor
  }//endfor
fclose(PATTERNFILE);
}

void LoadUserPattern(char *Fname) {
 int j, InVal;
FILE *PATTERNFILE;

printf("Loading pattern from file: %s\n", Fname);
fprintf(ARCHIVE,"Loading pattern from file: %s\n", Fname);
PATTERNFILE = fopen(Fname,"r");
if (PATTERNFILE==NULL){
 printf("Unable to open file: %s",Fname);
 exit(0);
 }

printf("\n");
for (j=0; j<NumNeurons; j++) {
  fscanf(PATTERNFILE,"%d",&InVal);
  NEURON[j]=InVal;
  }// endfor
fclose(PATTERNFILE);
}

void TrainNet(){
 int i,j,pat;
 int Sum;
for (i=0; i<NumNeurons; i++) {
 for (j=0; j<NumNeurons; j++) {
   Sum=0;
  for (pat=0; pat<NumPatterns; pat++) {
   Sum += (2*PatMatrix[pat][i]-1) * (2*PatMatrix[pat][j]-1);
   //Sum += PatMatrix[pat][i] * PatMatrix[pat][j];
   }/* endfor */
  T[j][i] = T[i][j] = Sum;
  }/* endfor */
 }/* endfor */
for (i=0; i<NumNeurons; i++) {    //Get rid of the diagonal...
 T[i][i]=0;                       // ...so it doesn't cause trouble later
 }/* endfor */
}

int QueryAllClean() {
 int i;
for (i=0; i<NumNeurons; i++) {
 if (Dirty[i]==TRUE) return FALSE;
 }//endfor
return TRUE;
}

void SetAllToDirty() {
 int i;
for (i=0; i<NumNeurons; i++) {
 Dirty[i]=TRUE;
 }//endfor
}

int UpdateNeuron(int j) {
 int i;
 int Sum = 0;
 int OldState = NEURON[j];
for (i=0; i<NumNeurons; i++) {    //accumulate all contributions
 Sum += T[j][i] * NEURON[i];      //remember we set diagonal of matrix T
                                    to 0 ..
                                  //     .. so no need to test for i==j
 }/* endfor */

if (Sum < 0) {
 NEURON[j] = 0;
 }
else {
 if (Sum>0)
  NEURON[j] = 1;
 }/* endif */

if (NEURON[j] == OldState) {
 return 0;
 }
else {
 return 1;
 } /* endif */
}

void RunNet(void) {
 int j;
 int Converged = FALSE;
 int ChngCount = 0;
 unsigned long int IterCount = 0;
 int ArchCnt=0;
SetAllToDirty();
while ((!Converged) && (IterCount < MAXlTER)) {
 j = random(NumNeurons);           //next updating neuron j);
 ChngCount += UpdateNeuron(j);     //increment if neuron changed state
 DisplayPatVect(NEURON);
  printf("RUNNING... Iteration=%d \n",IterCount);

if (ArchCnt>=9) {
 SavePatVect(NEURON, "Net output at iteration =", IterCount+1);
 ArchCnt=0;
  } else {
  ArchCnt++;
  }/* endif */
Dirty[j] = FALSE;                        //Record that we've covered this
                                           neuron

if (QueryAllClean()){                    //Check if we hit all neurons at
                                           least once
  //here if we have hit all at least once
  //DisplayPatVect(NEURON);
  if (ChngCount == 0) {                  //Check if any neurons changed
                                           this pass
   //if we're here then were converged
   Converged = TRUE;
   printf("\nCONVERGED");
  SavePatVect(NEURON, "Net after convergence at iteration=", IterCount);
   }
  else {
   //if here then NOT converged so reinit for another pass
   SetAllToDirty();
   ChngCount=0;
   }/* endif */
   }/* endif */
 IterCount++;                           //Increment iteration counter
 }/* endwhile */
}

void Initialize(int cnt, char *Name) {  //housekeeping
 char TrnName[50];
 char TstName[50];
ARCHIVE = fopen("ARCHIVE.LST","w");
if (ARCHIVE==NULL){
 printf("Unable to open default Training Set file: ARCHIVE.LST");
 exit(0);
 }
if (cnt>1) {
 //Get test pattern from file specified by command line arg
 strcpy(TrnName,Name);
 strcpy(TstName,Name); strcat(TstName,".tst");
 TrnName[4]=0; strcat(TrnName,"n4.trn");
 LoadTrainingSet(TrnName);
 if (cnt==2) LoadUserPattern(TstName);
 }
else {
 //Initialize net with random test pattern
 //no command line parms
 LoadTrainingSet("HOPNET1.TRN");          //Use default training set
 InitNetRand();                      //use random pattern
 }/* endif */

if (cnt>2) InitNetRand();            //parm count >2 --ignore pat file &
                                        randomize
KeyWait();
}

int main(int argc, char argv[]){
 int i;
Initialize(argc, argv[1]);
DisplayPatVect(NEURON);                //show net is set to test pattern
Save PatVect(NEURON, "Test Pattern",-1);
KeyWait2("TEST PATTERN");
DisplayPatterns();
TrainNet();
DisplayWeights();
RunNer();
fclose(ARCHIVE);
}

[n.forex]

4--Kohonen model

c-code

 ******************************
*KOHONEN NET                  *
******************************
#include <stdlib.h>
#include <stdio.h>
#include <math.h>

#define  MAXPATS 100
#define  MAXNEURONSIN 10
#define  MAXNEURONS 15

#define  MAXEPOCHS 1000
#define  ETAMIN .001

unsigned int Random(int N) {
 unsigned int j;
j= (N*rand())/RAND_MAX;
if (j>=N) j=N
return j;

}
class PATTERN {
 friend class KNET;
private:
 double       P[MAXPATS][MAXNEURONSIN];
 int          NumPatterns;
 int          Shuffle[MAXPATS];
 int          SizeVector;
public:
 PATTERN();
 int GetPatterns(char *);        //load pattern from file
 int GetRandPats(int,int);       //random patterns arg1 =# of patterns,
                                   arg2=dimension
 double Query(int,int);          //returns P[arg1][arg2]
 double QueryR(int,int);         //returns P[Shuffle[arg1]][arg2]
 void ReShuffle(int N);
};

PATTERN::PATTERN(){
int i;
for (i=0; i<MAXPATS; i++)
  Shuffle[i]=i;
}

int PATTERN::GetPatterns(char *fname) {
  FILE *fp;
  int i,j;
  double x;
fp=fopen(fname,"r");
if (fp==NULL) return 0;                 // Test for failure.
fscanf(fp,"%d",&NumPatterns);
fscanf(fp,"%d",&SizeVector);
for (i=0; i<NumPatterns; i++){          // For each vector
  for (j=0; j<SizeVector; j++){         // create a pattern
    fscanf(fp,"%Ig",&x);                // consisting of all elements
    P[i][j]=x;
    } /* endfor */
  } /* endfor */
fclose(fp);
return 1;
}

int PATTERN::GetRandPats(int n1,int n2){
  int i,j;
  double x;
NumPatterns=n1;
SizeVector=n2;
for (i=0; iNumPatterns; i++){           // For each vector
  for (j=0; j<SizeVector; j++){         // create a pattern
    x=(double)rand()/RAND_MAX;          // consisting of random elements
     P[i][j]=x;                         // between 0 and 1
     } /* endfor */
  } /* endfor */
return 1
}
void PATTERN: ReShuffle(int N){
int i,a1,a2,tmp;
for (i=0; i<N ;i++){
  a1 =Random(NumPatterns);
  a2=Random(NumPatterns);
  tmp=Shuffle[a1];
  Shuffle[a1]=Shuffle[a2];
  Shuffle[a2]=tmp;
  }
}

double PATTERN::Query(int pat,int j){
return P[pat][j];
}

double PATTERN::QueryR(int pat,int j) {
return P[Shuffle[pat][j];
}

class KNET {
private:
 double W[MAXNEURONSIN][MAXNEURONS];   // The weight matrix
 double Yout[MAXNEURONS];              // The output layer neurons
 double Yin[MAXNEURONSIN];             //The input layer neurons
 int  YinSize;                         //input layer dimensions
 int  YoutSize;                        //outlayer dimensions

 int  epoch;
 double eta;                           //The learning rate
 double delta_eta;                     //Amount to change l. r. each epoch
 int StochFig;                         //Present vectors in rand order if 1
 PATTERN *Pattern;

 int LoadInLayer(int);                 //pattern->input layer
 double EucNorm(int);                  //Calc Euclidean distance
 int FindWinner();                     //get coords of winning neuron
 void Train(int);
 void AdaptParms();
public:
 KNET();
 void SetPattern (PATTERN *);
 void SetParms(int, double);
 void PrintWeights();
 void PrintWinner();
 void RunTrn();
 void Run();
};
KNET::KNET(){
StochFig=0;
}

void KNET::SetPattern(PATTERN *p) {
 Pattern=p;
 YinSize=p->SizeVector;
}
void KNET::SetParms(int X, double LR){
 int i,k;
YoutSize=X;
eta=LR;
delta_eta=0.005;
for (i=0; i<YoutSize; i++) {
  for (k=0; k<YinSize; k++) {
    W[k][i]=(double)rand()/(10.0*(double)RAND_MAX);
    } /* endfor */
  } /* endfor */
}

int KNET::LoadInLayer(int P){
  int i;
for (i=0; i<YinSize; i++){
 if (StochFlg){
   Yin[i]=Pattern->QueryR(P,i);
   }
  else {
  Yin[i]=Pattern->Query(P,i);
  }
}
return 1;
}

void KNET::AdaptParms(){
eta=eta-delta_eta;
if (eta<ETAMIN)
   eta=ETAMIN;
printf("New eta=%f\n",eta);
}

void KNET::PrintWeights() {
 int i,k;
for (i=0; i<YoutSize; i++) {
    for (k=0; k<YinSize; k++) {
      printf("W[%d][%d]=%f ",k,i,W[k][i]);
      } /* endfor */
    printf ("\n");
  } /* endfor */
}

void KNET::RunTrn(){
int i,np;
int Winner;
epoch=0;

np=Pattern->Num Patterns;
while (epoch<=MAXEPOCHS){
 for (i=0; i<np; i++){
  LoadInLayer(i);
  Winner=FindWinner();
  Train(Winner);
  }
 if(5*(epoch/5)==epoch){
   printf("Epoch=%d\n”,epoch);
   PrintWeights();
   }
  epoch++;
  if (StochFlg)
    Pattern->ReShuffle(np);
  AdaptParms();
  }
}

void KNET::Train(int Winner){
 int k;
for (k=0; k<YinSize; k++){
   W[k][Winner]=W[k][Winner]+eta*(Yin[k]-W[k][Winner]);
   } /*endfor*/
}

int KNET::FindWinner(){
 int i;
 double d, best;
 int Winner;
best=1.0e99;
Winner=1;
for (i=0; i<YoutSize; i++){
  d=EucNorm(i);
  if (d<best) {
     best=d;
     Winner=i;
     } // endif
  } // endfor
return Winner;
}

double KNET::EucNorm(intx){            //Calc Euclidean norm of vector dif
int i;
double dist;
dist=0;
for (i=0; i< YinSize;i++){
  dist += (W[i][x]-Yin[i])*(W[i][x]-Yin[i]);
  } /* endfor */
dist=sqrt(dist);
return dist;
}

//===================================================================
// GLOBAL OBJECTS
//===================================================================

PATTERN InPat;
KNET net;

//===================================================================
// Main()
//===================================================================

main(int argc, char *argv[]){
//stand(17);
if (argc>1) {
   InPat.GetPatterns(argv[1];   //Establish pattern
   net.SetPattern(&InPat);      //Inform the feature map about the pattern
   net.SetParms(3, 0.500);      //Init fm parms
   net.RunTrn();                //Run the FM w/ training enabled
   }
  else {
   printf("USAGE: KNET PATTERN_FILE");
   }
}

[aBoRaMa]

بالرغم من أني علمت من أول مشاركة قرأتهه بأن الموضوع أشبه بأعماق البحار المظلمة، إلا أنني استمتعت بقراءة كل حرف كتب، وحتى آخر مشاركة

تحية إجلال لك ولأخونا ابو الطيب، ولكل من شارك وحرص على التعلم

[n.forex]

مثال
بين كيف يمكن أستعمال شبكه من نوع ( forward feeding perceptron) مكونه من أربع مدخلات و 2 مخرجات للعمل بالفوركس ؟

الحل :
-الشكل العام للشبكه:




المرحله الأولي -فرض المدخلات:
نفرض أن المدخلات ستكون 4 أشارات ستعطي للشبكه 1 للشراء و -1 للبيع

الأشاره 1:

if Macd above 0 then record 1

if Macd below  0 then record -1

اذا كان الماكد أكبر من 0 Input1=1
واذا كان الماكد أقل من 0 Input1=-1
الأشاره 2:

if RSI above 50 then record 1

 if RSI below 50 then record -1

اذا كان مؤشر RSI أكبر من 50 Input2=1 واذا كان أقل من 50 Input2=-1

الأشاره 3:

 if momentum  above 100 then record 1

if momentum below 100 then record -1

اذا كان مؤشر المومنتيوم أكبر من 100 Input 3=1
واذا كان مؤشر المومنتيوم أقل من 100 Input 3=-1

الأشاره 4:

if close[1] above open[1] then record 1

if close[1] below open[1] then record -1

اذا كانت الشمعه السابقه بيضاء Input4=1 واذا كانت الشمعه السابقه سوداء Input4=-1

ستكون المخرجات بهذه الصيغ
out1=Input1*W12+Input2*w21+Input3*w31+Input4*w41

out2=Input1*w11+Input2*w22+Input3*w32+Input4*w42
حيث * أشارة ضرب وتجري عملية الضرب قبل الجمع



المرحله الثانيه : تعليم الشبكه وأختيار الأوزان المناسبه

1- نفرض أننا سندخل بهدف 40 ووقف 40

2- سندخل شراء اذا كان out1 أكبر من buysholds

وسندخل بيع اذا كان out2 أكبر من sellsholds

حيث buysholds و sellsholds

أرقام تنسق هي والأوزان أثناء مرحلة التعليم
مرحلة التعليم:
1-سنعطي قيمه مبدئيه للأوزان
w12=0.1
w21=0.1
w31=0.1
w41=0.1

w11=-0.1
w22=-0.1
w32=-0.1
w42=-0.1

buysholds=1
sellsholds=1

أعطينا للأوزان قيمه مبدأئيه موجبه بحالة الشراء وسالبه بحالة البيع ونبدأ بتعليم الشبكه
الهدف 40 والوقف 40

if out1 more than buysholds  enter buy

if out2 more than sellsholds enter sell

اذا كان out1 أكبر من buysholds أدخل شراء واذا كان out2 أكبر من sellsholds أدخل بيع

بعد ذلك يتم التدريب لسنه مثلا وتخزن النتائج بنهاية السنه

نستمر بتغيير أوزان الشراء من 0.1 الي 0.9 و buysholds من 1 الي 3
حتي نحصل علي أفضل نتيجه

أوزان البيع من -0.1 الي -0.9 و sellsholds من 1 الي 3 حتي نحصل علي أفضل النتائج

ماذا يحصل أثناء مرحلة التعليم ؟
أثناء مرحلة التعليم سنغير الأوزان لكل أشارة شراء أو بيع واذا كان شرط الشراء الأول لمؤشر الماكد مهم ويزيد من الربح ستكون w12 كبيره (تجرب من 0.1 الي 0.9)وسيصبح الشرط الأول (الماكد أكبر من الصفر) له وزن أكبر من باقي الشروط وبحالة أرتفاع الماكد عن الصفر و w12=0.9 أما باقي الأوزان مثلا = 0.1
ستهتم الشبكه بمؤشر الماكد أكثر من باقي المؤشرات وربما لا تدخل شراء اذا كانت باقي المؤشرات تتسبب بخساره وحدثت أشاره شراء منها ويتم تعليم الشبكه علي ذلك بتغيير الأوزان و buysholds
حتي نحصل علي أفضل النتائج