Matrix RandomMatrix (int N, long seed) // // Returns a N by N matrix with uniformly distributed deviates in the // range [-0.5,0.5]. The index range for the matrix returned will be (1,N,1,N). // If the seed argument is omitted or set to Zero then you will get a // new random matrix whenever you call this function. // If you supply a seed (negative and positive numbers are // n o t distinct) you can reproduce the matrix of random numbers. // The random generator Rnd() is used. // { static Ran002 rnd; static UniformDistribution U(-0.5,0.5,&rnd); if (seed) { // a seed was given rnd = Ran002(seed); U = UniformDistribution(-0.5,0.5,&rnd); } if (N < 1) return NullMatrix; Matrix R(1,N,1,N); double *r = R.Store(); for (int i = 0; i < R.Elements(); i++) r[i] = U(); return R.Value(); }
void Node_Parameter::UpdateValue(double newstate, double newtime) { if (UniformDistribution(0, 1)<ParameterUpdateChance) { CurValue += (rand() % ParameterUpdateRange - ParameterUpdateRange / 2)*ParameterUpdateStep; } return; }
// Процедура самообучения агента на одном такте времени void AgentLearning(TNeuralNetwork* AgentNeuralNetwork, TLearningSettings* LearningSettings) { TNeuron* CurrentNeuron = AgentNeuralNetwork->NetworkStructure; //int MismatchCheck[AgentNeuralNetwork->NeuronQuantity]; // Массив признаков рассогласованности нейронов сети int* MismatchCheck = new int[AgentNeuralNetwork->NeuronQuantity]; // Массив признаков рассогласованности нейронов сети // Сначала определяем рассогласованность всех нейронов (чтобы избежать проверки рассогласованности вновь включающихся нейронов) while (CurrentNeuron != NULL) { if ((CurrentNeuron->Type == 1) && (CurrentNeuron->Active))// Если нейрон внутренний и он активен MismatchCheck[CurrentNeuron->ID - 1] = MismatchDetection(CurrentNeuron, LearningSettings->MismatchSignificanceTreshold); // Определяем есть ли рассогласование else MismatchCheck[CurrentNeuron->ID - 1] = 0; CurrentNeuron = CurrentNeuron->next; } // Проводим процедуру обучения CurrentNeuron = AgentNeuralNetwork->NetworkStructure; while (CurrentNeuron != NULL) { if (MismatchCheck[CurrentNeuron->ID - 1]) // Если есть рассогласование { TNeuron* ActivatedNeuron = FindMostActiveNeuron(AgentNeuralNetwork, CurrentNeuron); if (ActivatedNeuron != NULL) // Если найден хотя бы один подходящий нейрон в родительском пуле (он еще не активен и был возбужден на текущем шаге) { AgentNeuralNetwork->SynapseQuantity += ModifySynapseStructure(ActivatedNeuron); // Модифицируем его синаптические веса double WeightValue = 0; if (MismatchCheck[CurrentNeuron->ID - 1] == 1) // Если это первый тип рассогласования WeightValue = UniformDistribution(0.5, 1); else // Если это второй тип рассогласования WeightValue = - UniformDistribution(0.5, 1); // Добавляем связь между рассогласованным и включающимся нейроном AgentNeuralNetwork->SynapseQuantity += AddInterPoolConnection(ActivatedNeuron, CurrentNeuron, AgentNeuralNetwork->SynapseQuantity, WeightValue); AgentNeuralNetwork->PredConnectionQuantity += ModifyPredConnectionsStructure(ActivatedNeuron, CurrentNeuron, AgentNeuralNetwork->PredConnectionQuantity); ActivatedNeuron->Active = true; ActivatedNeuron->CurrentOut = 0; } } CurrentNeuron = CurrentNeuron->next; } delete []MismatchCheck; fix_synapses_id(AgentNeuralNetwork); fix_pred_connections_id(AgentNeuralNetwork); }
bool Node_Parameter::Mutation(Node** node) { double mutatechance = UniformDistribution(0, 1); if (mutatechance<NonOperationMutateChance) { (*node) = new Node_State(); return true; } else if (mutatechance<2*NonOperationMutateChance) { (*node) = new Node_Time(); return true; } return false; }
void GazeboOdometryPlugin::Load(physics::ModelPtr _model, sdf::ElementPtr _sdf) { if (kPrintOnPluginLoad) { gzdbg << __FUNCTION__ << "() called." << std::endl; } // Store the pointer to the model model_ = _model; world_ = model_->GetWorld(); SdfVector3 noise_normal_position; SdfVector3 noise_normal_quaternion; SdfVector3 noise_normal_linear_velocity; SdfVector3 noise_normal_angular_velocity; SdfVector3 noise_uniform_position; SdfVector3 noise_uniform_quaternion; SdfVector3 noise_uniform_linear_velocity; SdfVector3 noise_uniform_angular_velocity; const SdfVector3 zeros3(0.0, 0.0, 0.0); odometry_queue_.clear(); if (_sdf->HasElement("robotNamespace")) namespace_ = _sdf->GetElement("robotNamespace")->Get<std::string>(); else gzerr << "[gazebo_odometry_plugin] Please specify a robotNamespace.\n"; node_handle_ = gazebo::transport::NodePtr(new transport::Node()); // Initialise with default namespace (typically /gazebo/default/) node_handle_->Init(); if (_sdf->HasElement("linkName")) link_name_ = _sdf->GetElement("linkName")->Get<std::string>(); else gzerr << "[gazebo_odometry_plugin] Please specify a linkName.\n"; link_ = model_->GetLink(link_name_); if (link_ == NULL) gzthrow("[gazebo_odometry_plugin] Couldn't find specified link \"" << link_name_ << "\"."); if (_sdf->HasElement("covarianceImage")) { std::string image_name = _sdf->GetElement("covarianceImage")->Get<std::string>(); covariance_image_ = cv::imread(image_name, CV_LOAD_IMAGE_GRAYSCALE); if (covariance_image_.data == NULL) gzerr << "loading covariance image " << image_name << " failed" << std::endl; else gzlog << "loading covariance image " << image_name << " successful" << std::endl; } if (_sdf->HasElement("randomEngineSeed")) { random_generator_.seed( _sdf->GetElement("randomEngineSeed")->Get<unsigned int>()); } else { random_generator_.seed( std::chrono::system_clock::now().time_since_epoch().count()); } getSdfParam<std::string>(_sdf, "poseTopic", pose_pub_topic_, pose_pub_topic_); getSdfParam<std::string>(_sdf, "poseWithCovarianceTopic", pose_with_covariance_stamped_pub_topic_, pose_with_covariance_stamped_pub_topic_); getSdfParam<std::string>(_sdf, "positionTopic", position_stamped_pub_topic_, position_stamped_pub_topic_); getSdfParam<std::string>(_sdf, "transformTopic", transform_stamped_pub_topic_, transform_stamped_pub_topic_); getSdfParam<std::string>(_sdf, "odometryTopic", odometry_pub_topic_, odometry_pub_topic_); getSdfParam<std::string>(_sdf, "parentFrameId", parent_frame_id_, parent_frame_id_); getSdfParam<std::string>(_sdf, "childFrameId", child_frame_id_, child_frame_id_); getSdfParam<SdfVector3>(_sdf, "noiseNormalPosition", noise_normal_position, zeros3); getSdfParam<SdfVector3>(_sdf, "noiseNormalQuaternion", noise_normal_quaternion, zeros3); getSdfParam<SdfVector3>(_sdf, "noiseNormalLinearVelocity", noise_normal_linear_velocity, zeros3); getSdfParam<SdfVector3>(_sdf, "noiseNormalAngularVelocity", noise_normal_angular_velocity, zeros3); getSdfParam<SdfVector3>(_sdf, "noiseUniformPosition", noise_uniform_position, zeros3); getSdfParam<SdfVector3>(_sdf, "noiseUniformQuaternion", noise_uniform_quaternion, zeros3); getSdfParam<SdfVector3>(_sdf, "noiseUniformLinearVelocity", noise_uniform_linear_velocity, zeros3); getSdfParam<SdfVector3>(_sdf, "noiseUniformAngularVelocity", noise_uniform_angular_velocity, zeros3); getSdfParam<int>(_sdf, "measurementDelay", measurement_delay_, measurement_delay_); getSdfParam<int>(_sdf, "measurementDivisor", measurement_divisor_, measurement_divisor_); getSdfParam<double>(_sdf, "unknownDelay", unknown_delay_, unknown_delay_); getSdfParam<double>(_sdf, "covarianceImageScale", covariance_image_scale_, covariance_image_scale_); parent_link_ = world_->GetEntity(parent_frame_id_); if (parent_link_ == NULL && parent_frame_id_ != kDefaultParentFrameId) { gzthrow("[gazebo_odometry_plugin] Couldn't find specified parent link \"" << parent_frame_id_ << "\"."); } position_n_[0] = NormalDistribution(0, noise_normal_position.X()); position_n_[1] = NormalDistribution(0, noise_normal_position.Y()); position_n_[2] = NormalDistribution(0, noise_normal_position.Z()); attitude_n_[0] = NormalDistribution(0, noise_normal_quaternion.X()); attitude_n_[1] = NormalDistribution(0, noise_normal_quaternion.Y()); attitude_n_[2] = NormalDistribution(0, noise_normal_quaternion.Z()); linear_velocity_n_[0] = NormalDistribution(0, noise_normal_linear_velocity.X()); linear_velocity_n_[1] = NormalDistribution(0, noise_normal_linear_velocity.Y()); linear_velocity_n_[2] = NormalDistribution(0, noise_normal_linear_velocity.Z()); angular_velocity_n_[0] = NormalDistribution(0, noise_normal_angular_velocity.X()); angular_velocity_n_[1] = NormalDistribution(0, noise_normal_angular_velocity.Y()); angular_velocity_n_[2] = NormalDistribution(0, noise_normal_angular_velocity.Z()); position_u_[0] = UniformDistribution(-noise_uniform_position.X(), noise_uniform_position.X()); position_u_[1] = UniformDistribution(-noise_uniform_position.Y(), noise_uniform_position.Y()); position_u_[2] = UniformDistribution(-noise_uniform_position.Z(), noise_uniform_position.Z()); attitude_u_[0] = UniformDistribution(-noise_uniform_quaternion.X(), noise_uniform_quaternion.X()); attitude_u_[1] = UniformDistribution(-noise_uniform_quaternion.Y(), noise_uniform_quaternion.Y()); attitude_u_[2] = UniformDistribution(-noise_uniform_quaternion.Z(), noise_uniform_quaternion.Z()); linear_velocity_u_[0] = UniformDistribution( -noise_uniform_linear_velocity.X(), noise_uniform_linear_velocity.X()); linear_velocity_u_[1] = UniformDistribution( -noise_uniform_linear_velocity.Y(), noise_uniform_linear_velocity.Y()); linear_velocity_u_[2] = UniformDistribution( -noise_uniform_linear_velocity.Z(), noise_uniform_linear_velocity.Z()); angular_velocity_u_[0] = UniformDistribution( -noise_uniform_angular_velocity.X(), noise_uniform_angular_velocity.X()); angular_velocity_u_[1] = UniformDistribution( -noise_uniform_angular_velocity.Y(), noise_uniform_angular_velocity.Y()); angular_velocity_u_[2] = UniformDistribution( -noise_uniform_angular_velocity.Z(), noise_uniform_angular_velocity.Z()); // Fill in covariance. We omit uniform noise here. Eigen::Map<Eigen::Matrix<double, 6, 6> > pose_covariance( pose_covariance_matrix_.data()); Eigen::Matrix<double, 6, 1> pose_covd; pose_covd << noise_normal_position.X() * noise_normal_position.X(), noise_normal_position.Y() * noise_normal_position.Y(), noise_normal_position.Z() * noise_normal_position.Z(), noise_normal_quaternion.X() * noise_normal_quaternion.X(), noise_normal_quaternion.Y() * noise_normal_quaternion.Y(), noise_normal_quaternion.Z() * noise_normal_quaternion.Z(); pose_covariance = pose_covd.asDiagonal(); // Fill in covariance. We omit uniform noise here. Eigen::Map<Eigen::Matrix<double, 6, 6> > twist_covariance( twist_covariance_matrix_.data()); Eigen::Matrix<double, 6, 1> twist_covd; twist_covd << noise_normal_linear_velocity.X() * noise_normal_linear_velocity.X(), noise_normal_linear_velocity.Y() * noise_normal_linear_velocity.Y(), noise_normal_linear_velocity.Z() * noise_normal_linear_velocity.Z(), noise_normal_angular_velocity.X() * noise_normal_angular_velocity.X(), noise_normal_angular_velocity.Y() * noise_normal_angular_velocity.Y(), noise_normal_angular_velocity.Z() * noise_normal_angular_velocity.Z(); twist_covariance = twist_covd.asDiagonal(); // Listen to the update event. This event is broadcast every // simulation iteration. updateConnection_ = event::Events::ConnectWorldUpdateBegin( boost::bind(&GazeboOdometryPlugin::OnUpdate, this, _1)); }
// Функция отбора активирующихся нейронов void NeuronsSelection(TNeuralNetwork* PrimaryNetwork, double* const _SummaryPotential, int ActivationNeuronsQuantity) { double* const SummaryPotential = new double[PrimaryNetwork->NeuronQuantity]; memcpy(SummaryPotential, _SummaryPotential, sizeof(double) * PrimaryNetwork->NeuronQuantity); int InputOuputNeuronsQuantity = 0; TNeuron* CurrentNeuron = PrimaryNetwork->NetworkStructure; // Считаем кол-во входных и выходных нейронов while (CurrentNeuron != NULL) { if (CurrentNeuron->Type != 1) ++InputOuputNeuronsQuantity; CurrentNeuron = CurrentNeuron->next; } // Вариант с использованием рулеточного алгоритма // Работаем только с той частью списка, в которой записаны интер-нейроны // Сначала нормируем все значения - так чтобы у нейронов с отрицательным потенциалом была возможность отобраться double MinPotential = 0; // Ищем минимальный отрицательный суммарный потенциал for (int CurrentNeuron = InputOuputNeuronsQuantity; CurrentNeuron<PrimaryNetwork->NeuronQuantity; CurrentNeuron++) if (MinPotential > SummaryPotential[CurrentNeuron]) MinPotential = SummaryPotential[CurrentNeuron]; // Инвертируем оставшиеся потенциалы for (int CurrentNeuron = InputOuputNeuronsQuantity; CurrentNeuron<PrimaryNetwork->NeuronQuantity; CurrentNeuron++) SummaryPotential[CurrentNeuron] -= MinPotential - 1; // Делаем так, чтобы ни у одного нейрона не было нулевого суммарного потенциала double TotalPotential = 0; double CurrentNeuronsQuantity = 0; for (int CurrentNeuron = InputOuputNeuronsQuantity; CurrentNeuron < PrimaryNetwork->NeuronQuantity; CurrentNeuron++) TotalPotential += SummaryPotential[CurrentNeuron]; const double CheckEmpty = -5000.0F; // Признак выбранного элемента // Пока есть хотя бы один нейрон с ненулевым суммарным потенциалом и не набрано достаточно кол-во нейронов - прогоняем рулеточный алгоритм while (CurrentNeuronsQuantity<ActivationNeuronsQuantity) { double RandomPotential = UniformDistribution(0, TotalPotential, false, false);//(rand()%1000/1000.0) * TotalPotential; double CurrentPotential = 0; int CurrentNeuronNum = InputOuputNeuronsQuantity; //char tmp_str[10000]; //strcpy(tmp_str, ""); while (RandomPotential > CurrentPotential) { CurrentPotential += max(SummaryPotential[CurrentNeuronNum++], 0.0); //sprintf(tmp_str, "%s%i: %.4f : %.4f |\t", tmp_str, CurrentNeuronNum-1, max(SummaryPotential[CurrentNeuronNum-1], 0.0), CurrentPotential); } if (CurrentNeuronNum > PrimaryNetwork->NeuronQuantity){ printf("\n!! Error !! - %i (%i) - %.6f , %.6f , %.6f\n", CurrentNeuronNum, PrimaryNetwork->NeuronQuantity, RandomPotential, TotalPotential, CurrentPotential); //char c= getchar(); } //printf("%i(%i) ", CurrentNeuronNum, PrimaryNetwork->NeuronQuantity); // Уменьшаем суммарный потенциал на величину выбранного нейрона TotalPotential -= SummaryPotential[CurrentNeuronNum-1]; SummaryPotential[CurrentNeuronNum - 1] = CheckEmpty; //!!! CurrentNeuronsQuantity++; } /*Детерминированный вариант for (int i=0; i<ActivationNeuronsQuantity; i++) { double CurrentMax=-999; int CurrentMaxNumber; for (int j=InputOuputNeuronsQuantity; j<PrimaryNetwork->NeuronsQuantity; j++) if (CurrentMax < SummaryPotential[j]) { CurrentMax = SummaryPotential[j]; CurrentMaxNumber = j; } SummaryPotential[j] = -1000; }*/ //Изменяем информацию о нейронах (разделяем их на активные и молчащие) CurrentNeuron = PrimaryNetwork->NetworkStructure; while (CurrentNeuron!=NULL) { if (CurrentNeuron->Type == 1) if (SummaryPotential[CurrentNeuron->ID-1] == CheckEmpty) CurrentNeuron->Active = 1; else CurrentNeuron->Active = 0; else CurrentNeuron->Active=1; CurrentNeuron = CurrentNeuron->next; } delete []SummaryPotential; }
// Построение ПОЛНОЙ (без отбора) первичной нейронной сети из генотипа (структуры пулов) void BuildPrimaryNetwork(TNeuralNetwork* PrimaryNetwork, TPoolNetwork* PoolNetwork, double DevelopSynapseProbability, double DevelopPredConnectionProbability) { int NeuronsQuantity = 0; // Количество нейронов в первичной сети TNeuralPool* CurrentPool= PoolNetwork->PoolsStructure; // Ссылка на текущий пул TNeuron* CurrentNeuron = PrimaryNetwork->NetworkStructure; // Ссылка на текущий нейрон int MaxCapacity = 0; // Максимальная размерность пула // Находим максимальную размерность пула for (int PoolNumber = 0; PoolNumber < PoolNetwork->PoolQuantity; PoolNumber++) { if (CurrentPool->Capacity > MaxCapacity) MaxCapacity = CurrentPool->Capacity; CurrentPool = CurrentPool->next; } // Создаем двумерный массив ссылок на все нейроны первичной сети, разбитых на принадлежность к пулу (чтобы потом их не искать, когда добавляем связи) //printf("%i ", MaxCapacity); //TNeuron* PoolAndNetworkStructure[PoolNetwork->PoolQuantity][MaxCapacity]; TNeuron*** PoolAndNetworkStructure = new TNeuron**[PoolNetwork->PoolQuantity]; for (int i=0; i<PoolNetwork->PoolQuantity; ++i) PoolAndNetworkStructure[i] = new TNeuron*[MaxCapacity]; CurrentPool = PoolNetwork->PoolsStructure; // Проходим по всем пулам и создаем нейроны for (int PoolNumber = 0; PoolNumber < PoolNetwork->PoolQuantity; PoolNumber++) { // Создаем все нейроны пула for (int NeuronNumber = 0; NeuronNumber < CurrentPool->Capacity; NeuronNumber++) { if (CurrentNeuron == NULL) // Если в сети нет еще ни одного нейрона { PrimaryNetwork->NetworkStructure = CreateNeuron(++NeuronsQuantity, CurrentPool->Type, NormalDistribution(CurrentPool->BiasMean, CurrentPool->BiasVariance), CurrentPool->Layer, true, CurrentPool, CurrentPool->ID, NULL, NULL, NULL); CurrentNeuron = PrimaryNetwork->NetworkStructure; } else { CurrentNeuron->next = CreateNeuron(++NeuronsQuantity, CurrentPool->Type, NormalDistribution(CurrentPool->BiasMean, CurrentPool->BiasVariance), CurrentPool->Layer, true, CurrentPool, CurrentPool->ID, NULL, NULL, NULL); CurrentNeuron = CurrentNeuron->next; } PoolAndNetworkStructure[PoolNumber][NeuronNumber] = CurrentNeuron; } CurrentPool = CurrentPool->next; } CurrentPool = PoolNetwork->PoolsStructure; CurrentNeuron = PrimaryNetwork->NetworkStructure; int SynapsesQuantity = 0; // Количество синапсов сети int PredConnectionQuantity = 0; // Количество предикторных связей // Проходимсся по всем пулам и создаем синапсы for (int PoolNumber = 0; PoolNumber < PoolNetwork->PoolQuantity; ++PoolNumber) { for (int NeuronNumber = 0; NeuronNumber < CurrentPool->Capacity; ++NeuronNumber) { // Создаем синапсы TPoolConnection* CurrentConnection = CurrentPool->ConnectednessSet; TSynapse* CurrentSynapse = CurrentNeuron->InSynapses; // Пока мы не прошли все входные связи текущего пула while (CurrentConnection != NULL) { /*// Определяем количество входных связей для текущего нейрона от нейронов пресинаптического пула int CurrentSynapsesQuantity = rand() % 0.2*CurrentConnection->PrePool->Capacity; int PreNeuronNumber[CurrentSynapsesQuantity]; // Номера пресинаптических нейронов из текущего пресинаптического пула GenerateRandomNumbers(1, CurrentConnection->PrePool->Capacity, CurrentSynapsesQuantity, PreNeuronNumber); BubbleSort(PreNeuronNumber, CurrentSynapsesQuantity); for (int i=0; i<CurrentSynapsesQuantity; i++) // Создаем все текущие синапсы { if (CurrentSynapse = NULL) // Если нет еще ни одного синапса у текущего нейрона { CurrentNeuron->InSynapses = CreateSynapse(++SynapsesQuantity, NormalDistribution(CurrentConnection->WeightMean, CurrentConnection->WeightVariance), CurrentConnection->Enabled, PoolAndNetworkStructure[CurrentConnection->PrePool->ID-1][PreNeuronNumber[i]-1], CurrentNeuron, NULL); CurrentSynapse = CurrentNeuron->InSynapses; } else { CurrentSynapse->next = CreateSynapse(++SynapsesQuantity, NormalDistribution(CurrentConnection->WeightMean, CurrentConnection->WeightVariance), CurrentConnection->Enabled, PoolAndNetworkStructure[CurrentConnection->PrePool->ID-1][PreNeuronNumber[i]-1], CurrentNeuron, NULL); CurrentSynapse = CurrentSynapse->next; } }*/ // Проходимся по всем потенциальным пресинаптическим нейронам и определяем развивается ли связь if (CurrentConnection->Enabled) for (int CurrentPreNeuronNumber = 0; CurrentPreNeuronNumber < CurrentConnection->PrePool->Capacity; ++CurrentPreNeuronNumber ) { if (UniformDistribution(0, 1) <= DevelopSynapseProbability) { if (CurrentSynapse == NULL) // Если нет еще ни одного синапса у текущего нейрона { CurrentNeuron->InSynapses = CreateSynapse(++SynapsesQuantity, NormalDistribution(CurrentConnection->WeightMean, CurrentConnection->WeightVariance), CurrentConnection->Enabled, PoolAndNetworkStructure[CurrentConnection->PrePool->ID-1][CurrentPreNeuronNumber], CurrentNeuron, NULL); CurrentSynapse = CurrentNeuron->InSynapses; } else { CurrentSynapse->next = CreateSynapse(++SynapsesQuantity, NormalDistribution(CurrentConnection->WeightMean, CurrentConnection->WeightVariance), CurrentConnection->Enabled, PoolAndNetworkStructure[CurrentConnection->PrePool->ID-1][CurrentPreNeuronNumber], CurrentNeuron, NULL); CurrentSynapse = CurrentSynapse->next; } } } CurrentConnection = CurrentConnection->next; } //Создаем предикторные связи TPoolPredConnection* CurrentPredConnection = CurrentPool->PredConnectednessSet; TPredConnection* CurrentPredSynapse = CurrentNeuron->PredConnections; // Пока мы не прошли все входные предикторные связи текущего пула while (CurrentPredConnection != NULL) { /*// Определяем количество входных предикторных связей для текущего нейрона от нейронов пресинаптического пула int CurrentPredSynapsesQuantity = rand() % 0.2*CurrentPredConnection->PrePool->Capacity; int PreNeuronNumber[CurrentPredSynapsesQuantity]; // Номера пресинаптических нейронов из текущего пресинаптического пула GenerateRandomNumbers(1, CurrentPredConnection->PrePool->Capacity, CurrentPredSynapsesQuantity, PreNeuronNumber); BubbleSort(PreNeuronNumber, CurrentPredSynapsesQuantity); for (int i=0; i<CurrentPredSynapsesQuantity; i++) // Создаем все текущие предикторные связи { if (CurrentPredSynapse = NULL) // Если нет еще ни одной предикторной связи у текущего нейрона { CurrentNeuron->PredConnections = CreatePredConnection(++PredConnectionQuantity, CurrentPredConnection->Enabled, PoolAndNetworkStructure[CurrentPredConnection->PrePool->ID-1][PreNeuronNumber[i]-1], CurrentNeuron, NULL); CurrentPredSynapse = CurrentNeuron->PredConnections; } else { CurrentPredSynapse->next = CreatePredConnection(++PredConnectionQuantity, CurrentPredConnection->Enabled, PoolAndNetworkStructure[CurrentPredConnection->PrePool->ID-1][PreNeuronNumber[i]-1], CurrentNeuron, NULL); CurrentPredSynapse = CurrentPredSynapse->next; } }*/ // Проходимся по всем потенциальным пресинаптическим нейронам для текущей предикторной связи и определяем развивается ли связь if (CurrentPredConnection->Enabled) for (int CurrentPreNeuronNumber = 0; CurrentPreNeuronNumber < CurrentPredConnection->PrePool->Capacity; ++CurrentPreNeuronNumber) { if (UniformDistribution(0, 1) <= DevelopPredConnectionProbability) { if (CurrentPredSynapse == NULL) // Если нет еще ни одного синапса у текущего нейрона { CurrentNeuron->PredConnections = CreatePredConnection(++PredConnectionQuantity, CurrentPredConnection->Enabled, PoolAndNetworkStructure[CurrentPredConnection->PrePool->ID-1][CurrentPreNeuronNumber], CurrentNeuron, NULL); CurrentPredSynapse = CurrentNeuron->PredConnections; } else { CurrentPredSynapse->next = CreatePredConnection(++PredConnectionQuantity, CurrentPredConnection->Enabled, PoolAndNetworkStructure[CurrentPredConnection->PrePool->ID-1][CurrentPreNeuronNumber], CurrentNeuron, NULL); CurrentPredSynapse = CurrentPredSynapse->next; } } } CurrentPredConnection = CurrentPredConnection->next; } CurrentNeuron = CurrentNeuron->next; } CurrentPool = CurrentPool->next; } for (int i=0; i<PoolNetwork->PoolQuantity; ++i) delete [](PoolAndNetworkStructure[i]); delete []PoolAndNetworkStructure; // Заполняем данные про построенную сеть PrimaryNetwork->NeuronQuantity = NeuronsQuantity; PrimaryNetwork->SynapseQuantity = SynapsesQuantity; PrimaryNetwork->PredConnectionQuantity = PredConnectionQuantity; }
// Процедура генерации стартовой популяции для модернизированного эвлюционного алгоритма void InitFirstGeneration_ModernEvolution(TAgentGenomePopulation* AgentGenomePopulation, int EnvironmentResolution, int OutputResolution, int InitialPoolCapacity) { for (int CurrentAgent=0; CurrentAgent<AgentGenomePopulation->PopulationAgentQuantity; CurrentAgent++) // Создаем популяцию { AgentGenomePopulation->AgentGenome[CurrentAgent] = CreatePoolNetwork(); TNeuralPool* CurrentPool=NULL; int CurrentPoolNumber = 0; for (CurrentPoolNumber=0; CurrentPoolNumber < EnvironmentResolution; ++CurrentPoolNumber) // Создаем сенсорные пулы if (CurrentPool == NULL) // Если это первый пул { AgentGenomePopulation->AgentGenome[CurrentAgent]->PoolsStructure = CreateNeuralPool(CurrentPoolNumber + 1, 0, 1, UniformDistribution(-1,1), 0, 1, NULL, NULL, NULL); CurrentPool = AgentGenomePopulation->AgentGenome[CurrentAgent]->PoolsStructure; } else { CurrentPool->next = CreateNeuralPool(CurrentPoolNumber + 1, 0, 1, UniformDistribution(-1,1), 0, 1, NULL, NULL, NULL); CurrentPool = CurrentPool->next; } // Создаем выходные пулы for (CurrentPoolNumber=EnvironmentResolution; CurrentPoolNumber<EnvironmentResolution+OutputResolution; ++CurrentPoolNumber) { CurrentPool->next = CreateNeuralPool(CurrentPoolNumber + 1, 2, 1, UniformDistribution(-1,1), 0, 3, NULL, NULL, NULL); CurrentPool = CurrentPool->next; } // Создаем единственный вставочный пул CurrentPool->next = CreateNeuralPool(CurrentPoolNumber + 1, 1, InitialPoolCapacity, UniformDistribution(-1,1), 0, 2, NULL, NULL, NULL); CurrentPool = CurrentPool->next; TNeuralPool* CurrentPool_2 = AgentGenomePopulation->AgentGenome[CurrentAgent]->PoolsStructure; while (CurrentPool_2->Type != 2) // Находим первый вставочный нейрон CurrentPool_2 = CurrentPool_2->next; // Заполняем входящие связи выходных пулов от вставочного пула for (int CurrentConnectionNumber=0; CurrentConnectionNumber<OutputResolution; ++CurrentConnectionNumber) { CurrentPool_2->ConnectednessSet = CreatePoolConnection(CurrentConnectionNumber + 1, UniformDistribution(-1,1), 0, 1, static_cast<double>(CurrentConnectionNumber + 1), 0, CurrentPool, CurrentPool_2, NULL); CurrentPool_2 = CurrentPool_2->next; } CurrentPool_2 = AgentGenomePopulation->AgentGenome[CurrentAgent]->PoolsStructure; // Ссылка на первый сенсорный пул // Заполняем входящие связи вставочного пула от входных пулов TPoolConnection* CurrentConnection = NULL; for (int CurrentConnectionNumber=OutputResolution; CurrentConnectionNumber<OutputResolution+EnvironmentResolution; ++CurrentConnectionNumber) if (CurrentConnection == NULL) // Если это первая входящая связь у вставочного пула { CurrentPool->ConnectednessSet = CreatePoolConnection(CurrentConnectionNumber + 1, UniformDistribution(-1,1), 0, 1, static_cast<double>(CurrentConnectionNumber + 1), 0, CurrentPool_2, CurrentPool, NULL); CurrentConnection = CurrentPool->ConnectednessSet; CurrentPool_2 = CurrentPool_2->next; // Сдвигаемся на следующий сенсорный пул } else { CurrentConnection->next = CreatePoolConnection(CurrentConnectionNumber + 1, UniformDistribution(-1,1), 0, 1, static_cast<double>(CurrentConnectionNumber + 1), 0, CurrentPool_2, CurrentPool, NULL); CurrentConnection = CurrentConnection->next; CurrentPool_2 = CurrentPool_2->next; // Сдвигаемся на следующий сенсорный пул } AgentGenomePopulation->AgentGenome[CurrentAgent]->PoolQuantity = EnvironmentResolution + OutputResolution + 1; AgentGenomePopulation->AgentGenome[CurrentAgent]->ConnectionQuantity = EnvironmentResolution + OutputResolution; AgentGenomePopulation->AgentGenome[CurrentAgent]->PredConnectionQuantity = 0; } }