رد: تم حل شيفرة إكسبيرت الشبكات العصبيه
لو عدلنا اكسبرت يعطي نتائج جيدة بحيث انة يعتمد على نتائج سابقة مخزنة في قاعدة بيانات بحيث يكون في قاعدة البينات :::
8 الاف صفقة ناجحة مع معطيات المؤشرات وقتها
الفين صفقة خاسرة مع معطيات المؤشرات وقتها
بحيث يقوم برنامج الشبكة العصبية او الاكسبرت نفسة عند توفر شروط دخول الصفقة بالبحث في قاعدة البينات عن شروط مشابهه اذا كانت ناجحة او لا
بحيث انة اذا كانت ناجحة سابقا يقوم بالدخول فيها
اذا كانت خسرانة سابقا يمتنع عن الدخول فيها
اذا كانت شروط الصفقة لم تحدث من قبل وغير متوفرة بالقاعدة يقوم بتنفيذها وتسجيل نتيجتها بالقاعدة وبكذا يتعلم الاكسبرت ويعمل على تحقيق ارباح في نفس الوقت
انا مبرمج php و mysql واتوقع mql سهلة لاكن العقبة هي كوني مبتديء في الفوركس
رد: تم حل شيفرة إكسبيرت الشبكات العصبيه
تحية اجلال وتقدير لك ولاخونا ابو الطيب
رد: تم حل شيفرة إكسبيرت الشبكات العصبيه
اقتباس:
المشاركة الأصلية كتبت بواسطة kasper
لو عدلنا اكسبرت يعطي نتائج جيدة بحيث انة يعتمد على نتائج سابقة مخزنة في قاعدة بيانات بحيث يكون في قاعدة البينات :::
8 الاف صفقة ناجحة مع معطيات المؤشرات وقتها
الفين صفقة خاسرة مع معطيات المؤشرات وقتها
بحيث يقوم برنامج الشبكة العصبية او الاكسبرت نفسة عند توفر شروط دخول الصفقة بالبحث في قاعدة البينات عن شروط مشابهه اذا كانت ناجحة او لا
بحيث انة اذا كانت ناجحة سابقا يقوم بالدخول فيها
اذا كانت خسرانة سابقا يمتنع عن الدخول فيها
اذا كانت شروط الصفقة لم تحدث من قبل وغير متوفرة بالقاعدة يقوم بتنفيذها وتسجيل نتيجتها بالقاعدة وبكذا يتعلم الاكسبرت ويعمل على تحقيق ارباح في نفس الوقت
انا مبرمج php و mysql واتوقع mql سهلة لاكن العقبة هي كوني مبتديء في الفوركس
اهلا اخي الكريم ,,
على حسب مافهمت ان الشبكة العصبية هي تقوم ماتقوم به قاعدة البيانات ولكن تأخذ المعطيات من الشارت نفسه في نفس الوقت وبسرعة فائقة وهي بمثابة الفلتر للصفقات وايضا الميزة في الشبكة انها صغيرة الحجم .
ثانيا فكرتك رائعة جدا وانا سبق وان طرحتها على اخونا المبرمج trider ولكن لم يرد علي في هذا الموضوع وبما اني لاأملك العلم في البرمجة لااستطيع ان اعمل شي ولكن الفكرة ستكون ناجحة لأنه سيكون إكسبيرت ذكي لأنه يجمع شروط لإنجاح الصفقة بطريقة لايمكن ان تجمع في ملف اكسبيرت .
لكن الاخ تريدر قام بفكرة مبدئية قريبة من هذه وجديدة لم اراها في اكسبيرت سابقا وصمم اكسبيرت فيه خيارات لتجربة الاهداف والوقف وعند عمل باك تست يظهرلك كتابة على الشارت بعدد الصفقات السابقة الرابحة والخاسرة بالأعدادات التي وضعتها طبعا على ماأذكر اختار تقاطع الموفينق افرج للإستراتيجية الاكسبيرت المستخدم , لكن يفترض منه ان يكمل تطوير الاكسبيرت بحفظ هذه البيانات والشروط التي تم الدخول بها في كل صفقة و ان يضيف الشروط المرتبطة بين الصفقات الخاسرة كعامل مشترك لتحليل واستخراج العامل بين الصفقات الخاسرة مثلا التوقيت ومعدل الحركة اليومي وعلاقة العملات بين بعضها في حركتها هل هي مع بعضها او متعاكسة الحركة وايضا من هذه الشروط التي تعطي الاكسبيرت عوامل مهمة في حركة السعر لإيجاد سبب مشترك يتكرر في الصفقات الخاسرة لتسجيلة وتجنبه في المتاجرة المستقبلية .
وان شاءالله ناوي اتعلم هذه اللغة لأصيغ بعض الأفكار التي تراودني لصنع إكسبيرت ناجح
لكن ايضا تخصص برمجة الشبكات العصبية يدخل في مرحلة متقدمة في البرمجة لأن على ماقرأت لكل لغة برمجية منهج في برمجة الشبكات العصبية ولم أرى في المنتديات العربية المتخصصة في البرمجة مبرمج محترف لصنع هذه الشبكات لاأدري هل هو علم معقد زيادة على تعقيد البرمجة أم انه لايعتمد عليه في مشاريع البرمجة المتعارف عليها . ولاأدري هل له تخصص لوحدة في الجامعات لأني لم أرى في مناهج علم الحاسب والبرمجة في الجامعات انهم يدرسون هذا التخصص .
خلاصة الكلام , اذا كنت مستعد لعمل قاعدة البيانات وعندك الوقت وتريد فريق عمل فلنتعاون على ذلك ونفتح موضوع لهذا المشروع البرمجي لأنه مختلف عن موضوعنا هنا وايضا ليتم ترتيب الأفكار وتقسيم المهمات على كل شخص يريد المشاركة في هذا الموضوع.
, وشكرا على مبادرتك وطرحك للفكرة .
رد: تم حل شيفرة إكسبيرت الشبكات العصبيه
أخي kasper إن شاء الله سألقي نظرة على الاكسبيرت الذي إقترحته و يا رب يكون فاتحة خير
أشكرك أخي الكريم
أستاذ سمير نورت الموضوع وانا شاكر ردك الطيب و كل التحية و التقدير لك لما تبذله في خدمة هذا المنتدى
أشكرك أخي الحبيب
أخي DO$LAR أنا معك أنت و جميع الاخوة حتى النهاية حتى نصل لشيء يرضي الجميع
إن شاء الله
بارك الله بكم جميعا إخوتي الكرام
رد: تم حل شيفرة إكسبيرت الشبكات العصبيه
اقتباس:
المشاركة الأصلية كتبت بواسطة kasper
لو عدلنا اكسبرت يعطي نتائج جيدة بحيث انة يعتمد على نتائج سابقة مخزنة في قاعدة بيانات بحيث يكون في قاعدة البينات :::
8 الاف صفقة ناجحة مع معطيات المؤشرات وقتها
الفين صفقة خاسرة مع معطيات المؤشرات وقتها
بحيث يقوم برنامج الشبكة العصبية او الاكسبرت نفسة عند توفر شروط دخول الصفقة بالبحث في قاعدة البينات عن شروط مشابهه اذا كانت ناجحة او لا
بحيث انة اذا كانت ناجحة سابقا يقوم بالدخول فيها
اذا كانت خسرانة سابقا يمتنع عن الدخول فيها
اذا كانت شروط الصفقة لم تحدث من قبل وغير متوفرة بالقاعدة يقوم بتنفيذها وتسجيل نتيجتها بالقاعدة وبكذا يتعلم الاكسبرت ويعمل على تحقيق ارباح في نفس الوقت
انا مبرمج php و mysql واتوقع mql سهلة لاكن العقبة هي كوني مبتديء في الفوركس
فكره رائعه لو عملناها لكن المشكله كيف حنعرف أن الشروط متشابهه ونخزنها بقاعدة
البيانات؟؟؟؟؟؟
ما هي البيانات اللتخزنها شبكة Domdom ؟
رد: تم حل شيفرة إكسبيرت الشبكات العصبيه
طيعا مشكورين على هذا الجهد الكبير
لكن هل متاكدين انها شبكة عصبية قابلة للتعلم
لانه يبدو لي انها اوزان لشبكة عصبية تم تعليمها مسبقا وما هذه الا الاوزان لاكسبيرت محدد ولا يمكن تركيبها لاكسبيرت اخر
ارجو ان اكون مخطئا
لو هناك احد لمس نتائج التدريب او الطريقة ينورنا الله ينور عليكم جميعا.
رد: تم حل شيفرة إكسبيرت الشبكات العصبيه
أحبتي في الله
والله منذ مدة لم أجد موضوعا عميقا بهذا العمق
أتمنى أن يثمن الموضوع ...ويعاد تفعيله
وجزا الله أستاذنا دمدم خير الجزاء على جميل صنيعه
رد: تم حل شيفرة إكسبيرت الشبكات العصبيه
هل الأخ دوم دوم ما زال يدخل المنتدى
رد: تم حل شيفرة إكسبيرت الشبكات العصبيه
رد: تم حل شيفرة إكسبيرت الشبكات العصبيه
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);
};
رد: تم حل شيفرة إكسبيرت الشبكات العصبيه
2--Linear Associative Memory LAM
https://forum.arabictrader.com/uploaded/26575_0l.JPG
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;
}
رد: تم حل شيفرة إكسبيرت الشبكات العصبيه
3-Hopfield Networks
https://forum.arabictrader.com/uploaded/26575_55.JPG
https://forum.arabictrader.com/uploaded/26575_77.JPG
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);
}
رد: تم حل شيفرة إكسبيرت الشبكات العصبيه
4--Kohonen model
https://forum.arabictrader.com/uploaded/26575_124.JPG
https://forum.arabictrader.com/uploaded/26575_771.JPG
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");
}
}
رد: تم حل شيفرة إكسبيرت الشبكات العصبيه
بالرغم من أني علمت من أول مشاركة قرأتهه بأن الموضوع أشبه بأعماق البحار المظلمة، إلا أنني استمتعت بقراءة كل حرف كتب، وحتى آخر مشاركة
تحية إجلال لك ولأخونا ابو الطيب، ولكل من شارك وحرص على التعلم
رد: تم حل شيفرة إكسبيرت الشبكات العصبيه
مثال
بين كيف يمكن أستعمال شبكه من نوع ( forward feeding perceptron) مكونه من أربع مدخلات و 2 مخرجات للعمل بالفوركس ؟
الحل :
-الشكل العام للشبكه:
https://forum.arabictrader.com/uploaded/26575_TR.JPG
المرحله الأولي -فرض المدخلات:
نفرض أن المدخلات ستكون 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
حيث * أشارة ضرب وتجري عملية الضرب قبل الجمع
https://forum.arabictrader.com/uploaded/26575_g1.JPG
المرحله الثانيه : تعليم الشبكه وأختيار الأوزان المناسبه
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
حتي نحصل علي أفضل النتائج