Master.

سلام به هکمپی (زمینه کامپیوتر ویژن ) representation رو چی معنا کنیم بهتره ؟ نمایش بصری؟ نمایش؟ تصویر؟

4 فصل آخر حذف شدن یا از اول نبودن ؟ متن تدریس ایشون تو این زمینه هایی که عنوان شد رو شما ندارید ؟

سلام به همگی عزاداری همه قبول کسی اطلاعاتی در مورد Convolutional Networks داره ؟ کتاب یا آموزش ؟ خیلی ممنون میشم کسی چیزی داره راهنمایی کنه من یکسری منبع پیدا کردم : [Hidden Content] [Hidden Content] [Hidden Content] ولی بصورت مختصر رد میشن و بنظرم جالب نیومدن زیاد پیشایش از همه ممنونم

خب الحمدالله بلطف خدا متوجه شدم داستان چیه . اولا ما تغییرات وزن به اون معنایی که متبادر میشه به ذهن رو انجام نمیدیم . ما گرادیانت ارور رو جمع میکنیم و بعد میانگین اون رو برای محاسبه تغییرات وزن لحاظ میکنیم . خب این یعنی چی ؟ خب از اول ساده میریم جلو قدم اول این بود که ما خطا رو در لایه آخر بدست بیاریم و برای بدست آوردن خطا ما داشتیم error = desired_output - network_output یعنی جواب دلخواه منهای خروجی شبکه ما خطای شبکه رو بما میداد . (حالا اگه ما تو لایه آخر بیشتر از 1 نورون داشته باشیم بصورت زیر میشد معادله ما ) for (int i =0; i<numberOfOutputNeurons; i++ { error[i] = desired_output[i] - network_output[i]; } خب حالا ما ارور رو بدست آوردیم . باید با استفاده از این وزنها رو آپدیت کنیم . برای اینکه بفهمیم هر وزن چقدر تغییر باید بکنه ما میایم و خطایی که بدست اوردیم رو در اون وزن لحاظ میکنیم . و چون لایه آخر با لایه های قبل یک تفاوتی تو محاسبه داره ما دونوع محاسبه داریم . دلیل تفاوت داشتن لایه اخر با لایه های قبلی اینه که خطایی که ما بدست اوردیم مربوط به همون لایه آخر هست . یعنی ما خطای هر نورون رو بدست اوردیم . وزنهای هر نورون هم خب براحتی میشه با لحاظ کردن خطای بدست اومده از همون نورون بدست اورد. اما لایه های دیگه بصورت غیرمستقیم روی این خطا تاثیر میزارن و ما باید این تاثیر غیرمستقیم رو لحاظ کنیم . خب برای محاسبه تغییرات وزن در لایه آخر ما از فرمول زیر استفاده میکنیم gradient of error = f'(output) * error خب به این میگن گرادیانت ارور یا حساسیت (sensivity ) یا گرادیانت محلی (local gradient) (دلتا هم بهش میگن ). اینا همش اسمهای این ضریب ما هست . برای اینکه من وزنی رو در لایه آخر بدست بیارم کافیه از فرمول زیر استفاده کنم deltaW = gradientOfError * input و وزن جدید هم میشه W = W + alpha * deltaW (که آلفا همون نرخ یادگیری هست ) برای لایه های قبلی هم تقریبا به همین صورته با این تفاوت که error در فرمول زیر از یه رابطه غیرمستقیم بدست میاد : gradient of error = f'(output) * error error از رابطه زیر بدست میاد Sum of All (gradientofError k * W_jk یعنی چی ؟ یعنی اینکه برای بدست آوردن خطای یک نورن در لایه مخفی ما میایم اول نرونهایی که این نورون به اون ها وصل هست رو مشخص میکنیم (فرض کنید یه شبکه داریم دوتا لایه داره . لایه شماره 1 که لایه مخفی هست و لایه شماره 2 که لایه خروجی هست . نورون i در لایه 1 هست که که به چندتا نورون تو لایه 2 وصل هست(مثلا 2 تا نورون تو لایه آخر هستن با اسم های j1 و j2 ) حالا برای اینکه خطای نورون i رو بدست بیاریم . میایم گرادیانت محلی (گرادیانت ارور ) هر نورون تو لایه 2 که به نورون i وصل هست رو ضرب در وزن یالی میکنیم که نورون i با اون به این نورونها وصله . مثلا فرض کنید نورون i به دوتا نورون تو لایه 2 وصل هست . پس دوتا وزن داریم که از نورون i به این دوتا نورون میره ( هرکدوم یک وزن ) . حالا ما اینا رو باهم جمع میکنیم یعنی error_i = gradientError_i_j1 * w_i_j1 + gradientError_i_j2 * w_i_j2 و حالا میشه گرادیانت محلی نورون i رو بدست آورد که میشه gradient of error for neuron i = f'_i(output) * error_i و برای بدست آوردن وزن هم دقیقا مثل قبل عمل میکنیم . deltaW = gradientOfError * input و نهایتا مثل قبل W = W + alpha * deltaW خب پس این شد یک مختصر توضیح اولیه کار . تو بچ لرنینگ ما این گرادیانتها رو با هم جمع میکنیم و بعد میانگین میگیریم و بعد اون رو تو اپدیت وزنها دخالت میدیم . حالا این باز یعنی چی ؟ فرض کنید ما 4 تا نمونه داریم و تعداد مراحل تمرینی ما هم 10 هست (epoch) . تو متد آنلاین یا افزایشی ما هر بار که یک نمونه رو به شبکه ارائه میکردیم . خروجی شبکه رو میگرفتیم بعد ارور رو حساب میکردیم بعد گرادیانت محلی و بعدم دلتا دبلیو رو حساب میکردیم بصورت قبل و بعد وزنها رو بروز میکردیم . و بعدش میرفتیم و نمونه بعدی رو میخونیدم و به همین ترتیب شبکه رو دوباره تنظیم میکردیم . پس عمل تنظیم شبکه به ازای هر نمونه انجام میشد . اما در متد بچ لرنینگ (دسته ای ) ما به ازای هر مرحله تمرینی کامل عمل اپدیت وزنها و تنظیم شبکه رو انجام میدیم . هر مرحله تمرینی هم شامل ارائه همه نمونه ها به شبکه است . یعنی وقتی همه مثالها رو به شبکه دادیم یک دور تمرین تموم میشه . و برای دور بعد تمرین ما مثالها رو دوباره به شبکه ارائه میکنیم . خب نکته بچ لرنینگ هم همینجاست . ما تا وقتی که تمام مثالها (نمونه ها) تموم نشدن میایم و به ازای هر نمونه خروجی شبکه رو حساب میکنیم گرادیانت محلی رو حساب میکنیم و بعد deltaW رو حساب میکنیم . (یک نکته خیلی مهم اینجا هست که پایین میگم) . حالا این دلتا دبلیو رو ذخیره میکنیم . میریم سراغ نمونه بعدی دوباره تا همین مرحله میایم و یک دلتا دبلیو جدید بدست میاد این رو هم با قبلیه جمع میکنیم . بعد میریم سراغ نمونه بعدی و این کار رو تا وقتی که همه نمونه ها تموم بشن ادامه میدیم . حالا قبل از اینکه بریم و دور بعدی تمرین رو شروع کنیم باید عمل اپدیت وزنها رو انجام بدیم . اینجا باید این دلتا دبلیویی که بدست اوردیم رو تقسیم بر تعداد نمونه ها کنیم . یک میانگین بدست میاد . و این میانگین میشه دلتادبلیو نهایی ما و وزن جدید ما هم مثل قبل بصورت زیر بدست میاد : W = W + alpha * deltaW_Avg خب نکته ای که میخواستم در موردش صحبت کنم اینه که ممکنه خیلی جاها ببینید تو بدست اوردن دلتا دبلیو از آلفا یا لرنینگ ریت یا نرخ خوندن هم استفاده میکنن . اینجا اگه اون آلفا رو لحاظ کنید به مشکل بر میخورید و تو میانگین گیری حتما باید بدون آلفا پیش برید . مثلا در کتاب Neural Networks and Learning Machins ویرایش سوم (ویرایش های قبلی هم همینطوره ) دقیقا اینطور اومده : ( که اینجا اِتا (همون که شبیه n هست ) همون لرنینگ ریت هست دلتا همون دلتا (گرادیانت خطا یا گرادیانت محلی یا حساسیت) هست و yi هم یعنی ورودی نورون j (که میشه خروجی نورون i که با y_i نشون داده )) (اشکال کار من هم دقیقا همین بود . دقت کردید دیگه این کار (لحاظ کردن آلفا در دلتا دبلیو) تو ورژن افزایشی یا آنلاین مشکلی ایجاد نمیکه بخاطر ماهیتش اما تو ورژن دسته ای مشکل ایجاد میکنه . (این کتاب هم دقیقا فقط همین رو توضیح داده بود و برای دسته ای کلی گویی کرده بود ) منم از همین خورده بودم . تو صحبتهایی هم که تو اینترنت میکنن بی هوا فقط میگن تغییرات وزن رو ذخیره کنید و من حتی یکجا دیده بودم طرف میگفت با آلفا (لرنینگ ریت) ذخیره کن! و باعث شد که یک هفته تمام تقریبا صبح تا شب دنبال نخود سیاه باشم . الحمدالله بلطف خدا کتاب Martin T Hagan Neural Network Design 2nd edition که لینکشم تو تاپیک شبکه های عصبی گذاشتم این بخش رو توضیح داد و من متوجه اشتباهم شدم . امیدوارم این مطالب بدرد افراد دیگه هم بخوره و مثل من انقدر به مشکل برنخورن نهایتا کد ما برای این بخش بشکل زیر در اومد : //chapter11 page 370, Neural Networks Design by Martin T Hagan 2nd edition, // you can find the needed explanation on how to implement this there, // I actually did that by reading that section again. // note that, the gradient or sensivity he is talking about in his book // is the delta here, I named it delta, since the other book that I have, //called it delta, actually the correct name is gradient of error, which makes sense completely by the way. //remember what you do to calculate the delta (or gradient of error ) , you multiply the gradient of transformation function with the error // as a reminder , remembr f'(output) * error which is the formula to compute delta (gradient of error or local gradient ) for output layer // and in order to calculate the delta ( or local graidnet or gradient of error ) you had to multiply the hidden neurons transformation functions gradient //with the sum of next layers gradient of error and the weight of connection edge from hidden neuron to the next layers neurons. // as a reminder again , remember this : f'(output_i) * SUMOf_k_nextneurons(delta_k * w_ik) // that we could write it as : f'(output_i) * SUMOf_k_nextneurons(delta_k * outputRout_i_to_k) //the term local gradients and delta are said in Neural Networks and Learning Machins (chapter 4 ) //and the term gradient of error or sensivity is called in the Martin T Hagans book (Neural Network Design 2nd edition ) //as a final note, deltaw and deltaB, are just simply ΔW and ΔB (delta wight and delta bias respectively), // here they mean, the changes in weight and bias respectively . //last changes: 10/3/2015 16:45 PM vector<double> Network::TrainBatch(bool showtrace) { int epoch = 0; auto firstLayer = GetFirstLayer(); auto outputLayer = GetOutputLayer(); auto outputNeurons = outputLayer->GetNeurons(); std::map<Layer*, UpdateContainer> container; vector<double> errorSum(GetEpoch(), 0); for (auto &layer : GetLayers()) { container[layer].SetLayer(layer); } while (epoch < GetEpoch()) { //reset the updates and get ready for the next round for (auto & cons : container) cons.second.Clear(); vector<float> e; //choose a pattern for (int patternNumber = 0; patternNumber < GetInputs().size(); patternNumber++) { auto pattern = GetInputs()[patternNumber]; auto d = GetTarget()[patternNumber]; //feed the first layer with the new pattern input firstLayer->SetInputs(pattern); auto outputs = outputLayer->GetOutput(); //calculate its error double errors = 0, delta = 0; e.clear(); for (int i = 0; i < outputs.size(); i++) { e.push_back(d[i] - outputs[i]); //save accumulative updates of errors for graph plotting stuff errors += e[i]; if (showtrace) cout << "\n(e,d) " << e[i] << ", " << d[i] << "\t"; } errorSum[epoch] += std::powf(errors, 2) / 2; //note: whereever you see delta, its actuallt the gradient Of Error //except for deltaw or deltabias which denote the changes for weight and bias respectivly //for output neuron //delta_j = f'(output_j) * e_j for (int i = 0; i < outputNeurons.size(); i++) { delta = outputNeurons[i]->GetDerevative() * e[i]; container[outputLayer].SetDelta(i, delta); } //for output neuron //deltaw_j = alpha * delta_j * input_j //calculate the new weights for the output layer neurons int nIndex = 0; float newdelta = 0; for (auto &n : outputNeurons) { delta = container[outputLayer].GetDelta(nIndex); for (size_t i = 0; i < n->GetInputCount(); i++) { newdelta = (delta * n->GetInput(i)); container[outputLayer].AddDeltaWeight(nIndex, i, newdelta); } newdelta = (delta); //deltaBias container[outputLayer].AddDeltaBias(nIndex, newdelta); nIndex++; } //HIDDEN LAYERS //for hiddent neuron_i //delta_i = f'(output_i) * outputRoute_i_to_j * delta_j auto currentLayer = outputLayer->GetPreviousLayer(); while (currentLayer) { int nIndex = 0; int neuronIndex = 0; float sum = 0; float delta; float nextNeuronsDelta=0; int deltaIndex = 0; for (auto &n : currentLayer->GetNeurons()) { neuronIndex = 0; for (auto nextNeuron : currentLayer->GetNextLayer()->GetNeurons()) { nextNeuronsDelta = container[currentLayer->GetNextLayer()].GetDelta(neuronIndex++); sum += nextNeuronsDelta * n->GetOutputRouteFor(nextNeuron); } delta = n->GetDerevative() * sum; container[currentLayer].SetDelta(deltaIndex, delta); deltaIndex++; } //for hidden neuron //deltaw_i = alpha * f'(output_i) * SUMOf_k_nextneurons(delta_k * w_ik) * input_i //equals //deltaw_i = alpha * f'(output_i) * SUMOf_k_nextneurons(delta_k * outputRout_i_to_k) * input_i nIndex = 0; for (auto &n : currentLayer->GetNeurons()) { delta = container[currentLayer].GetDelta(nIndex); for (size_t i = 0; i < n->GetInputCount(); i++) { newdelta = (delta * n->GetInput(i)); container[currentLayer].AddDeltaWeight(nIndex, i, newdelta); } newdelta = (delta ); container[currentLayer].AddDeltaBias(nIndex, newdelta); nIndex++; } //if there is any more hidden layers, continue the process currentLayer = currentLayer->GetPreviousLayer(); if (!currentLayer) { break; } }//end of hidden layer processings //go for the next try } //update each layer with the updated info. for (auto &layer : GetLayers()) { if (layer->GetType() == Layer::LayerType::Output) layer->SetError(e); layer->SetDelta(container[layer].GetDeltas()); layer->SetDeltaBias(container[layer].GetDeltaBias()); layer->SetDeltaWeight(container[layer].GetDeltaWeight()); } //update all weights UpdateWeightsBatch(showtrace, container); epoch++; } return errorSum; } void Network::UpdateWeightsBatch(bool showtrace, std::map<Layer*, UpdateContainer>& containers) { for (auto item : containers) { int j = 0; int count = 0; auto container = item.second; auto layer = container.GetLayer(); for (auto neuron : layer->GetNeurons()) { for (size_t i = 0; i < neuron->GetInputCount(); i++){ container.GetDeltaWeight()[j][i] = container.GetDeltaWeight()[j][i] / GetInputs().size();//averaging individual gradients container.GetDeltaWeight()[j][i] *= GetLearningRate(); container.AddDeltaWeight(j,i,neuron->GetWeights()[i]); } container.GetDeltaBias()[j] = container.GetDeltaBias()[j] / GetInputs().size(); //average of bias gradients container.GetDeltaBias()[j] *= GetLearningRate(); container.AddDeltaBias(j, neuron->GetBiasWeight()); j++; } if (!showtrace) { for (auto &n : layer->GetNeurons()) { n->UpdateBias(container.GetDeltaBias()[count]); n->UpdateWeights(container.GetDeltaWeight()[count]); count++; } } else { cout << "\n$$$$$$$$$$$$$$$ Layer " << layer->GetId() << " $$$$$$$$$$$$$$$\n"; for (auto &n : layer->GetNeurons()) { ShowNeuronInfo(n, false); n->UpdateBias(container.GetDeltaBias()[count]); n->UpdateWeights(container.GetDeltaWeight()[count]); ShowNeuronInfo(n); count++; } cout << "\n$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$"; } } }

سلام . وقت همگی بخیر . یکسره میرم سر اصل مطلب . تو شبکه های عصبی چندتا شیوه برای train کردن وجود داره . دو روش کلی اون : یکی )incremental learning یا online learning هست و دومی) هم Batch learning من اولی رو تونستم پیاده سازی کنم و جواب هم گرفتم . ولی تو دومی مشکل دارم . تو کتابها من خوندم میگن تو بچ لرنینگ ما آپدیتها رو به ازای هر epoch انجام میدیم (برخلاف حالت اول که برای هر نمونه این اپدیت رو رو شبکه اعمال میکنیم ) . و برای این کار ما تغییرات وزن و بایاس ها رو با هم جمع میکنیم و بعد هرچی شد قبل از رفتن به epoch بعدی (دور بعدی تمرین) اپدیت میکنیم . این یه الگوریتم الگوریتم دیگه که من دیدم میگفتن فقط کافیه خطای لایه آخر رو به ازای تمام سمپلها در هر epoch بدست بیارید و بعد تقسیم بر تعداد سمپلها کنید تا یه میانگین از خطا بدست بیاد حالا با استفاده از این خطا خیلی راحت تغییرات وزن و بایاس رو حساب و اعمال کنید رو شبکه و برید برای دور بعدی . کدوم یکی از این دو الگوریتم درست هستن ؟ نمونه پیاده سازی شده ای ازش دارید (ترجیحا سی++ جاوا یا سی شارپ؟ ) من الگوریتم اول رو پیاده کردم اما اصلا converge نمیکنه . چه epoch رو 5 بزارم چه 800هزار (هر دوتا رو تست کردم ) و اصلا کانورج نمیکنه . ورژن دوم رو تست کردم جواب میده (کانورج میکنه ) اما نمیدونم واقعا بچ بحساب میاد یا نه . اگر میاد چرا از روش اول استفاده میشه . روش دوم که خیلی بهینه تر هست و فضای کمتری میگیره . این یه نمونه کد به سی++ هست که نحوه کار منو نشون میده . (بخشی از کتابخونه ای هست که نوشتم برای شبیه سازی شبکه های عصبی ) int epoch = 0; auto firstLayer = GetFirstLayer(); auto outputLayer = GetOutputLayer(); auto outputs = outputLayer->GetOutput(); auto outputNeurons = outputLayer->GetNeurons(); std::map<Layer*, UpdateContainer> container; vector<double> errorSum(GetEpoch(), 0); for (auto &layer : GetLayers()) { container[layer].SetLayer(layer); } while (epoch < GetEpoch()) { //reset the updates and get ready for the next round for (auto & cons : container) cons.second.Clear(); vector<float> e; //choose a pattern for (int patternNumber = 0; patternNumber < GetInputs().size(); patternNumber++) { auto pattern = GetInputs()[patternNumber]; auto d = GetTarget()[patternNumber]; //feed the first layer with the new pattern input firstLayer->SetInputs(pattern); //calculate its error float errors = 0, delta = 0; e.clear(); for (int i = 0; i < outputs.size(); i++) { e.push_back(d[i] - outputs[i]); //save accumulative updates of errors errors += e[i]; if (showtrace) cout << "\n(e,d) " << e[i] << ", " << d[i] << "\t"; } errorSum[epoch] = errors; //for output neuron //delta_j = f'(output_j) * e_j for (int i = 0; i < outputNeurons.size(); i++) { delta = outputNeurons[i]->GetDerevative() * e[i]; container[outputLayer].SetDelta(i, delta); } //for output neuron //deltaw_j = alpha * delta_j * input_j //calculate the new weights for the output layer neurons int nIndex = 0; float newdelta = 0; for (auto &n : outputNeurons) { delta = container[outputLayer].GetDelta(nIndex); for (size_t i = 0; i < n->GetInputCount(); i++) { newdelta = (delta * GetLearningRate() * n->GetInput(i)); container[outputLayer].AddDeltaWeight(nIndex, i, newdelta); //cout << epoch << " O_" << j << "_" << i << "<<" << dlt << "<<" << oDeltaWSum[j][i] << "\n"; } newdelta = (delta * GetLearningRate()); //deltaBias container[outputLayer].AddDeltaBias(nIndex, newdelta); nIndex++; } //HIDDEN LAYERS //for hiddent neuron_i //delta_i = f'(output_i) * outputRoute_i_to_j * delta_j auto currentLayer = outputLayer->GetPreviousLayer(); while (currentLayer) { int nIndex = 0; int neuronIndex = 0; float sum = 0; float delta; float nextNeuronsDelta=0; int deltaIndex = 0; for (auto &n : currentLayer->GetNeurons()) { neuronIndex = 0; for (auto nextNeuron : currentLayer->GetNextLayer()->GetNeurons()) { //hDeltaSum[currentLayer->GetNextLayer()][neuronIndex++] nextNeuronsDelta = container[currentLayer->GetNextLayer()].GetDelta(neuronIndex++); sum += nextNeuronsDelta * n->GetOutputRouteFor(nextNeuron);//neuronIndex is incremented each time (changed : 9/16/2015) } delta = n->GetDerevative() * sum; container[currentLayer].SetDelta(deltaIndex, delta); deltaIndex++; } //for hidden neuron //deltaw_i = alpha * f'(output_i) * SUMOf_k_nextneurons(delta_k * w_ik) * input_i //equals //deltaw_i = alpha * f'(output_i) * SUMOf_k_nextneurons(delta_k * outputRout_i_to_k) * input_i nIndex = 0; for (auto &n : currentLayer->GetNeurons()) { delta = container[currentLayer].GetDelta(nIndex); for (size_t i = 0; i < n->GetInputCount(); i++) { newdelta = (delta * GetLearningRate() * n->GetInput(i)); container[currentLayer].AddDeltaWeight(nIndex, i, newdelta); //cout <<epoch<< " H"<< currentLayer->GetId()<<"_"<<j<<"_"<<i<<"<<" << dlt<<"<<"<< hDeltaWSum[currentLayer][j][i] << "\n"; } newdelta = (delta * GetLearningRate()); container[currentLayer].AddDeltaBias(nIndex, newdelta); nIndex++; } //if there is any more hidden layers, continue the process currentLayer = currentLayer->GetPreviousLayer(); if (!currentLayer) { break; } }//end of hidden layer processings //go for the next try } for (auto &layer : GetLayers()) { if (layer->GetType() == Layer::LayerType::Output) layer->SetError(e); layer->SetDelta(container[layer].GetDeltas()); layer->SetDeltaBias(container[layer].GetDeltaBias()); layer->SetDeltaWeight(container[layer].GetDeltaWeight()); } //update all weights UpdateWeightsBatch(showtrace, container); //cout << epoch << "\n"; epoch++; } return errorSum; }

کسی نیست یه کمکی بما بکنه ؟ !

سلام خیلی ممنونم بله حق باشماست اصلا حواسم نبود دیگه انقدر تغییر داده بودم بخشای مختلفش رو یادم رفته بود اینودرست کنم چیزایی که گفتید رو انجام دادم اما باز هیچ تغییری نکرد . نه خروجی تغییری کرد نه وزنها و بایاسها هیچکدوم آپدیت شدن!!! % XOR calculator using BackPropagation clear all;clc; %specify input samples (creating trainings set) pattern = [1 1; 0 0; 1 0; 0 1]; [patternRows,patternCols] = size(pattern); %creating targets or desired answers for each set target = [0,0,1,1]; %initializing weights with random values w1 = [-1 1 ; %neuron 1 -1 2]; %neuron two w2 = [-2,0.5]; %outputneuron %bias b12 = [1 -1]; % for neuron one and two respectively b3 = -1.5; % for neuron three (output neuron) lr = 0.01; %learning rate a12 = [2 1]; %layer 1 outputs (neuron one and twos output respectively) a3 = 1; %layer 2 output (neuron 3 output) delta = 0; i=1; while (i<1000 || error ~=0) for row_number = 1: patternRows for neuron = 1:2 %calculate the output of each neuron a12(neuron) = logsig( pattern(row_number,:) * w1(neuron,:)' + b12(neuron) ); end %calculate the output a3 = hardlim(w2(:)'*a12(:)+ b3 ); %calculate the error error = target(row_number) - a3; %calculate the local gradient (sensivity) %which is f'(n) * e(n) for output layer SM = a3*error; %calculating delta which is learningrate * localgradient*inputs delta = lr * SM * a12; %updating the weights of last layer w2 = w2 + delta; %updating the last layers bias b3 = b3 + lr * SM; %calculating local gradients(sensivities) for hiddent layers %which is f(n)*SumOfNextLayers(localgradient*weights) Sm = [a12(1)*(1-a12(1)) 0; 0 a12(2)*(1-a12(2)) ] * w2' * SM ; %calculating delta which is the same as before delta = (lr .* Sm)* pattern(row_number,:); %updating the weights and biases of hidden layer w1 = w1 + delta; b12 = b12 + (lr * Sm)'; sss = sprintf('%d ) a3= %d # e= %d # w1=%d,%d # w2 =%d,%d \n',i,a3 ,error,w1(1),w1(2),w2(1),w2(2)); fprintf(' %s ',sss); end i= i+1; end این هم ورژنی که بایاس رو در قالب وزن در نظر گرفتم : %XOR calculator ( biases as weights ) % training set % (the last number is bias coefficent which is always 1 ts=[0 0 1;1 1 1; 1 0 1;0 1 1]; % targets or desired outputs d=[0 0 1 1]; % weights for hidden layers % bias ,weight1, weigth2 wh=[rand() rand() rand() ; rand() rand() rand()]; % wiegths from hidden layer to output layer % bias, weight1, weigth2 wo=[rand() rand() rand()]; %output for neuron 1 and 2 and bias for neuron3 a=[1 1]; %output for neuron 3 a3=0; %learning rate n=0.1; iteration=100; i=0; while (i<iteration || e~=0) for tindex=1:4 for neuron=1:2 a(neuron)= logsig(wh(neuron,:)*ts(neuron,:)'); end output_neuronsInput = wo(1)*a(1)+wo(2)*a(2)+wo(3)*1; a3 = hardlim(output_neuronsInput); e = d(tindex) - a3 % neuron 3(output) localgrad_out = a3*e; deltaW = n * localgrad_out * output_neuronsInput; wo = wo + deltaW; % neuron 1 grad_h = a(1)*(1-a(1)) * localgrad_out * wo(1)' deltaW = n * grad_h * wh(1,:); wh(1,:) = wh(1,:) + deltaW % neuron 2 grad_h = a(2)*(1-a(2)) * localgrad_out*wo(2)' deltaW = n * grad_h * wh(2,:) wh(2,:) = wh(2,:) + deltaW end i=i+1; end این هم ورژن بدون بایاس : %XOR without any biases% training set ts=[0 0; 1 1; 1 0; 0 1]; d=[0 0 1 1]; % weights for hidden layers (each row represents wiegths for the corrosponding neuron wh=[rand() rand(); rand() rand()]; % wiegths from hidden layer to output layer wo=[rand() rand()]; % output for neuron 1 and 2 and bias for neuron3 a=[1 1]; % output for neuron 3 a3=0; % learning rate n=0.1; iteration=10; i=0; while (i<iteration || e~=0) for tindex=1:4 for neuron=1:2 a(neuron)= logsig(wh(neuron,:)*ts(neuron,:)'); end a3 = hardlim(wo(1)*a(1)+wo(2)*a(2)) e = d(tindex) - a3 grad_out = a3*e; deltaW = n*grad_out*a; wo = wo+deltaW; grad_h = a(1)*(1-a(1)) * grad_out*wo(1)' deltaW = n*grad_h*wh(1,:); wh(1,:)= wh(1,:) +deltaW grad_h = a(2)*(1-a(2)) * grad_out*wo(2)' deltaW = n*grad_h*wh(2,:) wh(2,:) = wh(2,:) +deltaW end i=i+1; end

سلام وقت همه شما بخیر من تازه شبکه های عصبی رو شروع کردم و این اولین برنامه آزمایشی من هست . یک شبکه XOR که بوسیله backpropagation خودشو تصحیح میکنه و خروجی درست رو باید بده . من کد متلب زیر رو نوشتم اما جواب نمیگیرم . انگار هیچی آپدیت نمیشه ! ممنون میشم یکی راهنمایی کنه مشکل من از کجاست % in the name of GOD the most compassionate the most merciful % XOR calculator using BackPropagation clear all;clc; %specify input samples (creating trainings set) pattern = [1 1; 0 0; 1 0; 0 1]; [patternRows,patternCols] = size(pattern); %creating target or desigred answers for each set target = [0,0,1,1]; %initializing wiegths with random values w1 = [-1 1 ; %neuron 1 -1 2]; %neuron two w2 = [-2,0.5]; %outputneuron %bias b12 = [1 -1]; b3 = -1.5; lr = 0.01; %learning rate a12 = [2 1]; %layer 1 outputs a3 = 1; %layer 2 output delta = 0; while (i<10 || error ==0) for row_number = 1: patternRows for neuron = 1:2 %calculate the output of each neuron a12(neuron) = logsig( pattern(row_number,:) * w1(neuron,:)' + b12(neuron) ); end %calculate the output a3 = hardlim(w2(:)'*a12(:)+ b3 ); %calculate the error error = target(row_number) - a3; %for outputlayer %calculate the delta %delta = learning rate * local gradient(sensivity) * inputs %localgrad(sensivity) = f'(n)*e(n) SM = a3*error; delta = lr * SM *a12; w2 = w2-delta; b3 = b3-lr*SM; %now for the output neurons %sensivity or localgrad = f'(n).w(m+1).s(m+1); %neuron 1 Sm = [a12(1)*(1-a12(1)) 0, 0 a12(2)*(1-a12(2)) ] * w2' * SM ; delta = (lr .* Sm)* pattern(row_number,:); w1 = w1-delta; b12 = b12 - (lr*Sm)'; sss = sprintf('%d ) a3= %d # e= %d # w1=%d,%d # w2 =%d,%d \n',row_number,a3 ,error,w1(1),w1(2),w2(1),w2(2)); fprintf(' %s ',sss); i= i+1; end end یه توضیح هم بدم در مورد فرمول ها : فرمولها همون فرمولهای معمولی بک پراپگیشن هستن (من از کتاب هاگان گرفتم که اینجا هم آپلودکردم برای محاسبه وزن و بایاس های جدید از لایه آخر به این صورت عمل میکنیم اول باید حساسیت رو حساب کنیم حساسیت لایه آخر از ضرب مشتق تابع تبدیل در ارور بوجود اومده بدست میاد بعد باید اختلاف وزن جدید (دلتا) رو بدست بیاریم که میشه وزن قدیمی لایه آخر منهای (نرخ یادگیری ضربدر حساسیت لایه آخر* ورودی از لایه قبل ) برای نورونهای موجود تو لایه مخفی هم تقریبا مثل بالاست با این تفاوت که حساسیت = مشتق تابع تبدیل ضربدر حساسیت لایه بعدی ضربدر وزن لایه بعدی برای وزن هم میشه مثل بالا ----------------- نحوه کار منم اینه که اول یه حلقه کلی داریم که یه شمارنده داره مثلا گفتم این کار رو 10 بار تکرار کن . (iteration ماست مثلا) بعد تو حلقه دوم گفتم به تعداد سطرهای ماتریس sample ما که 4 تا هست بیا و این کارا رو انجام بده (این sample همون training set ما هست مثلا) تو حلقه بعدی اومدم اطلاعات مربوط به نورونهای لایه اول رو حساب کردم (یعنی ورودی در وزن اونها + بایاس اونها و نهایتا محاسبه خروجی تابع تبدیل اونها ) و نتیجه رو گذاشتم تو یه وکتور 2 ستونی . ستون اول مال نورون اول و ستون دوم مال نورون دوم ) زیرش لایه آخر که یک نورون هم بیشتر نداره حساب کردم و خروجیش رو گفتم بذار a3 . خب تا اینجا feedforward تموم شد . الان نوبت back-propagation هست . اول اومدم error لایه آخر رو حساب کردم که میشه خروجی شبکه منهای جواب مورد نظر ما (که از وکتور ستونی target میگیریم) حالا باید گرادیانت محلی (همون حساسیت ) لایه آخر رو حساب کنیم که این میشه مشتق تابع تبدیلش ضرب در ارور بدست اومده از مرحله قبل بعدش نوبت محاسبه دلتا هست که میشه ضرب نرخ یادگیری در گرادیانت محلی در ورودی های نورون لایه آخر حالا دلتا حساب شد اونو کم میکنیم از وزنی که قراره آپدیت بشه . همین کارم با بایاسش میکنیم . خب لایه آخر کارش تموم شد حالا نوبت لایه قبلش هست . اونم مثل قبل حساسیتش رو حساب میکنیم (همون گرادیانت محلیش ) که فقط فرقش اینه که مشتق این ضرب در گرادیانت محلی لایه بعد * وزن یالهای لایه بعد هست که به این لایه وصل هستن ) دلتا هم مثل قبل حساب میشه وزن و بایاس هم بروز میشه حالا تموم میشه و وزنها و بایاس ها باید آپدیت شده باشن تو دور بعدی دوباره همین مراحل تکرار میشن اما این بار با وزنها و بایاس های بروز شده . و این تا زمانی که خطای ما 0 بشه و یا تعداد تکرارهای ما تموم بشه ادامه پیدا میکنه -------------- مشکل هم اینجاست که هیچ اتفاقی نمی افته اصلا ! و داده ها همون هستن که قبلا بودن! انگار هیچی نمیشه !

عکسای این آموزش مربوط به کتاب Neural Networks Design هست نوشته آقای مارتین هاگان . کتاب خیلی فوق العاده ای هست و میشه آخرین ورژن اون رو رایگان از اینجا دانلود کرد : [Hidden Content] 26 فصله و خیلی عالی توضیح داده (البته یکسری جاهاش کتاب Neural Network a comprehensive foundation بهتر توضیح داده ) وقتی کتاب رو دانلود کردید نمونه های متلبش رو هم دانلود کنید : [Hidden Content] (پایین صفحه لینکش هست) برای هر فصلش چندتا برنامه متلب هست که بصورت تصویری چیزی که یادگرفتید تو اون فصل رو نمایش میده برای فهمیدن خیلی عالیه (مثلا برنامه همین چیزی که خانوم افشار اینجا توضیح دادن اونجا هست با توضیحاتش )

چرا تو بعضی جاها بجای اینکه خیلی راحت ماتریس رو بنویسن اونو transpose میکنن و تو معادله وارد میکنن ؟ مثلا اینجا از عکس 4.8 به بعد اومده از ماتریس ترانهاده تو فرمول استفاده کرده در حالی که خیلی راحت میتونست اینکارو نکنه! تو فرمول ترانهاده مینویسه اما تو عمل همون ماتریس معمولیه! میشه کسی بگه چرا اینکارو میکنه ؟ میتونید صفحاتی که درموردش صحبت میکنم رو اینجا ببینید : [Hidden Content] فهمیدم دلیلش چیه :) این اومده هر سطر ماتریس وزن رو در قالب یک وکتور نوشته ( وکتور یک ماتریس تک ستونه هست ) و این کار هم برای این شده که بتونیم خروجی رو به اضای هر نورون جداگانه بدست بیاریم در نتیجه برای ضرب داخلی دو بردار هم دترمینان یکی در بردار دیگه ضرب میشه . (تو ضرب ماتریس ها سطر با ستون یکی باید برابر باشه بنابر این یکی دترمینان میشه وگرنه نمیشه ضربشون کرد )

سلام خیلی ممنونم من اون صفحه مربوطه رو جدا کردمو آپلود کرده بودم آخر پستم لینکش بود : بابت راهنمایی هم خیلی ممنونم

سلام به همگی من دارم از روی کتاب Neural Networks Design میخونم . تا اینجا که کتاب بی نظیری بوده و فوق العاده درس داده . یک جا من متوجه نمیشم چی داره میگه کسی میتونه راهنمایی کنه ؟ اینکه میگه با توجه به شکل ما میتونیم ببینیم که مرز خطی که این وکتور رو بصورت متقارن از همدیگه جدا میکنه plane p1 ,p3 هست . From this figure we can see that the linear boundary that dividesthese two vectors symmetrically is the plane. اولا شکلش چطور رسم شده . سه تا محور باید داشته باشه درسته ؟ ( من ریاضیم خیلی ضعیفه ) چطوری این رسم شده من گیج شدم کامل بعد این مرزی که صحبتش رو میکنه دقیقا به چی اشاره داره کسی میتونه توضیح بده که دقیقا چی میخواد بگه و چطور به این رسیده ؟ وکتور P1 +1 -1 -1 و وکتور p2 +1 +1 -1 هست من اون صفحه رو آپلود کردم ممنون میشم کسی میتونه کمک کنه لینک صفحه کتاب

خیلی ممنون

Digital Image Processing Using MATLAB, 2nd ed. 2nd Edition by Rafael C. Gonzalez Richard E. Woods Steven L. Eddins ورژن با کیفیت این کتاب رو من دوران کارشناسی داشتم . پاکش کرده بودم چون یادم میاد حجم زیادی داشت. بعد 5 6 سال دوباره مجبور شدم دنبال کتاب بگردم . اما تمام کتابها 50 60 مگ بودن نهایتا و با کیفیت افتضاح .خلاصه با بدختی آخرش تو تورنت پیدا کردم و اپلودش کردم . کیفیت بسیار بالاست و رنگی هم هست . اسکن شده هم نیست و میشه کپی کرد همه چیز رو Download : [Hidden Content] پسورد: www.noandishaan.com اینم لینک 4shared : Digital Image Processing Using Matlab Rafael C. Gonzalez (Colored High Quality 2009) - Télécharger - 4shared - Seyyed Hossein Hasan Pour حجم این کتاب 220 مگابایته . خفه شدم تا پیداش کردم . پس شما هم هر جا تونستید ریشر کنید و آپلود کنید که دیگه گم به گور نشه ! این هم یکسری اسکرین شات :

لینکهای libgen کار نمیکنن . میشه یه mirror بدین ؟