Geekly articles weekly

Code de neuroélément



Bonjour chère communauté GeekTimes! Il n'y a pas si longtemps, une série d'articles consacrés aux travaux sur la création d'un modèle du système nerveux a été publiée ici. Et la meilleure façon de comprendre la logique du modèle est d'étudier le code du programme pour sa mise en œuvre. Je veux non seulement transmettre mes idées plus en détail, mais aussi demander de l'aide à la communauté. Je sais que parmi les lecteurs GT il y a beaucoup de professionnels dans le domaine de l'écriture de code logiciel et de votre expérience, les connaissances peuvent aider au développement du projet. Parfois, des conseils ou des recommandations compétents suffisent à rendre la solution d'une tâche aussi inhabituelle élégante et facile.

Cycle de contenu
1. . 1.
2. . 2.
3. . 3.
4. ,
5.
6.
7.

L'environnement de développement est Unity3D, un moteur de jeu très populaire. Cet environnement s'est avéré très pratique et accessible à la fois en travaillant avec l'éditeur et en présence d'un grand nombre de références, explications et commentaires en russe. Par conséquent, mes modestes compétences en programmation étaient suffisantes pour réaliser mes idées en utilisant Unity3D.

Les plans ne changent pas l'environnement de développement, car le moteur de jeu permet de résoudre facilement les problèmes de visualisation, ce qui est très important à ce stade.

Je tiens à m'excuser auprès de ceux qui veulent se tourner vers le code pour sa négligence, la négligence possible de la syntaxe du langage et les erreurs possibles. Quand j'ai commencé ce travail, il n'y avait aucune démonstration de code dans les plans. Je voulais tester certaines de mes hypothèses.

Le code reflète une recherche créative. Dans le processus de travail, j'ai été confronté à un autre problème, le modèle ne voulait pas agir comme je l'imaginais. Et pendant la journée, l'idée de résoudre ce problème pourrait me venir. À ces moments, je peux être inspiré par une sorte de perspicacité. De retour de travail, j'ai fait des corrections avec impatience, ignorant toutes les règles du code, il n'y avait pas de temps pour cela. Et combien de fois cela se produit, ces informations n'ont pas donné de résultats ou n'ont pas donné le résultat souhaité. Le travail sur le projet s'est donc poursuivi et merci pour la patience de ma femme qui m'a permis de mener ce travail. Il est difficile de trouver du temps entre la famille, le travail, votre propre procrastination et la paresse dans le travail de routine de normalisation du code. Même si cela devra encore être fait un jour.

Dans mon travail, j'ai adhéré à un modèle quelque peu inhabituel du neurone. Un modèle de neurone, comme un neurone biologique, pourrait agir de manière asynchrone à partir du travail d'autres neurones. Les signaux des clés des récepteurs, tels que ceux des récepteurs de la peau, peuvent ne pas être synchronisés. Par conséquent, dans les premiers modèles, sous l'influence de la pensée stéréotypée, j'ai distingué certaines phases de l'état dans le neurone qui durent un certain nombre d'étapes (cycles) de l'ensemble du système, et les étapes du système ont été effectuées de manière synchrone dans tous les neurones. Cela n'a pas fonctionné correctement et c'était terriblement inconfortable. Mais il fallait en quelque sorte synchroniser les signaux entrants et sortants et les évaluer correctement.

À un certain moment, l'idée est venue qu'un internaute a par la suite surnommé le «réservoir de vidange». Le modèle du «réservoir de vidange» s'est révélé étonnamment précis et applicable à un neurone biologique, il expliquait très clairement les mécanismes de sommation et était plus pratique à mettre en œuvre. Désormais, les neurones émulés pourraient être complètement indépendants, tout comme les objets réels.



Ce modèle d'additionneur est le modèle de neurone biologique le plus précis que je connaisse. Pour simuler une cellule gastrique en détail, il faudra une puissance de traitement incroyablement grande, mais tout ce que cette cellule fait est de produire l'enzyme ou l'hormone appropriée si nécessaire. Attribuer des propriétés de calcul incroyables à un neurone est très populaire parmi la cybernétique moderne.

Par la suite, certains mécanismes de la théorie des réflexes et l'idée de l'orientation directionnelle des paramètres de puissance de synapse sortants ont été ajoutés au modèle de sommation. Le modèle résultant a permis de créer une base théorique, qui expliquait tout simplement de nombreux processus et phénomènes qui se produisent dans le système nerveux. Les mécanismes réflexes, la mémoire et la consolidation de la mémoire, l'auto-organisation et la spécialisation des neurones, le travail du cervelet, les mécanismes émotionnels et la pensée sont tous dans une seule bouteille.

Je ne vais pas ennuyer. Lien vers le référentiel GitHub .

Par exemple, le code du script qui contient la logique principale du fonctionnement de l'élément neuronal NeironScript.cs (désolé pour mon français):

Beaucoup de code
using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class NeironScript : MonoBehaviour {

	public GameObject prefabNeiron;          // 
	public GameObject prefabSinaps;          // 

	public int IndexNeiron = 0;              // 

	private int _TypeIndexNeiron = 0;        //  

	public int TypeIndexNeiron               //  
	{
		get { return _TypeIndexNeiron; }
		set {
			if (value == 0) 
				{ _TypeIndexNeiron = value;
				  gameObject.GetComponent<SpriteRenderer>().color = new Color32(255, 255, 0, 255);//, 
				}	
			if (value == 1) 
				{ _TypeIndexNeiron = value;
				gameObject.GetComponent<SpriteRenderer>().color = new Color32( 0, 255, 0, 255); //,  //
				}	
			if (value == 2) 
				{ _TypeIndexNeiron = value;
				gameObject.GetComponent<SpriteRenderer>().color = new Color32(0, 255, 255, 255);//,  
				}
			if (value == 3) 
				{ _TypeIndexNeiron = value;
				gameObject.GetComponent<SpriteRenderer>().color = new Color32(255, 255, 255, 255);//,  
				}
			}
	}
	//   0
	public float Adder = 0.0f; 										//

	public float MaxAdder = 30f;									//  

	public float DampferAdder = 1.0f; 								// 
	public float thresholdTop = 1.0f; 								//  
	public float AnswerTime = 0.1f;      							// 
	public float TimeRepose = 0f;       							//  

	public bool IgnoreInput = false; 								//  
	public List<GameObject> hitSinaps = new List<GameObject>();  	// 

	public GameObject Area; 										//

	private bool _ActionN;											//  
	
	public bool ActionN												//  
	{
		get { return _ActionN; }
		set 
		{
			_ActionN = value;
			if (Area != null)
			{
				gameObject.GetComponent<LineRenderer>().enabled = value; //  ..
                bool existAction = Area.GetComponent<AreaScript>().NeironActionList.Contains(gameObject); //existAction = true -       
				if (_ActionN && (!existAction)) Area.GetComponent<AreaScript>().NeironActionList.Add(gameObject); //    
				else Area.GetComponent<AreaScript>().NeironActionList.Remove(gameObject); //    
			}
		}
	}

	//   1 

	public float thresholdDown = -5.0f;			 		//  
	public float timeIgnore = 5.0f;   					//        
	public float bonusThreshold = 0f; 					//   
	public float DempferBonusThreshold = 1.0f; 			//   
	public float TimeEvaluation = 5.0f;					// 
	public int LimitRecurrence = 5; 					// 
	public float thresholdTopUp = 1.0f;					//   

	public bool TimeEvaluationBool = false;				// 
	public int LimitEvaluationInt = 0;					//     

	public float AdaptationTime = 0;                    // 
	public float thresholdAdapt = 1f;                   //  

	//   2

	public float MaxForceSinaps = 100f;
	private Vector3 VectorPattern; 						// 
	public Vector3 VectorTrend; 						// 

	public float Charge = 0.0f; 						//
	public float TimeCharge = 0.01f; 					//   

	private float changeAngle = 0f; 					//  

	public float FocusNeiron = 90f;						// 
	public bool FocusDinamic = true;                    //  
	public float StepFocus = 1f;						//  
	public float MaxFocus = 90f;						//  

	public float Plasticity = 1.0f; 					//
	public bool PlasticityDinamic = true; 				//   
	public float StepPlasticity = 0.01f;				// 
	public float BasicPlasticity = 1.0f;				//  (  )
	public bool NewNeironDinamic = true;				//   

	

	private float angleMin = 0f;

	private bool CorunPlasticRun = false;

	// END VAR

    private Vector3 noveltyVector = Vector3.zero;
    private float noveltyFactor = 0.1f;

	IEnumerator StartSummator (){
		IgnoreInput = true;  //   
		gameObject.GetComponent<SpriteRenderer>().color = new Color32(255, 0, 0, 255); // 
		ActionN = true; //    
		yield return new WaitForSeconds(AnswerTime); // 
		ActionN = false; 
		ExcitationTransfer (); // 
		yield return new WaitForSeconds(TimeRepose);// 
		IgnoreInput = false; //    
		TypeIndexNeiron = _TypeIndexNeiron; //   
	}

	IEnumerator repolarizationTime (){
		IgnoreInput = true; //   
		gameObject.GetComponent<SpriteRenderer>().color = new Color32(0, 0, 255, 255);//  
		yield return new WaitForSeconds(timeIgnore);// 
		IgnoreInput = false;
		TypeIndexNeiron = _TypeIndexNeiron;//  
	}

	IEnumerator StartModule (){
        IgnoreInput = true; //   
		ActionN = true; // ,      
		gameObject.GetComponent<SpriteRenderer>().color = new Color32(255, 0, 0, 255);// 
		yield return new WaitForSeconds(AnswerTime);// 
		ExcitationTransfer ();//    
		ActionN = false;//  
		yield return new WaitForSeconds(TimeRepose);// 
		IgnoreInput = false;//   
		TypeIndexNeiron = _TypeIndexNeiron;// 
		StartCoroutine ("EvaluationTime");//  
		if ((AdaptationTime > 0) && (thresholdTop > thresholdAdapt)) StartCoroutine ("AdaptationVoid");// ,     =0   
        //         
	}

	IEnumerator EvaluationTime(){ 
		TimeEvaluationBool = true;//   
		yield return new WaitForSeconds(TimeEvaluation);
		TimeEvaluationBool = false;//  
	}

	IEnumerator AdaptationVoid(){
		yield return new WaitForSeconds(AdaptationTime);//  
        if (thresholdTop > thresholdAdapt) thresholdTop--;// ,    
		if ((AdaptationTime > 0) && (thresholdTop > thresholdAdapt)) StartCoroutine ("AdaptationVoid");//  
	}

	IEnumerator NegativeRepolarization(){
		IgnoreInput = true; //   
		ActionN = true; //
        for (int i = 0; i < 16; i++)
        {  //  
			Charge = Area.GetComponent<AreaScript>().Spike2[i];
			if (Charge > 0) gameObject.GetComponent<SpriteRenderer>().color = new Color32(255, 0, 0, 255); //
			else gameObject.GetComponent<SpriteRenderer>().color = new Color32(0, 0, 255, 255); //
			yield return new WaitForSeconds(TimeCharge); //  /
		}
		Charge = 0f;// 
		TypeIndexNeiron = _TypeIndexNeiron;// 
		ActionN = false;//
		IgnoreInput = false;//    
	}

	IEnumerator StartAssociative(){
		IgnoreInput = true;//  
		ActionN = true;//
        StartCoroutine("PositiveRepolarization"); //   
		yield return new WaitForSeconds(AnswerTime); 		//  
		Compass ();//  
	}

	IEnumerator StartWhite() {
        IgnoreInput = true;//  
        ActionN = true;//
        StartCoroutine("PositiveRepolarization");//   
		yield return new WaitForSeconds(AnswerTime); 		// 
		ExcitationTransfer ();//    
	}

	IEnumerator PositiveRepolarization(){
		for (int i = 0; i < 16; i++) {
            //  
			Charge = Area.GetComponent<AreaScript>().Spike1[i];
			if (Charge > 0) gameObject.GetComponent<SpriteRenderer>().color = new Color32(255, 0, 0, 255); //
			else gameObject.GetComponent<SpriteRenderer>().color = new Color32(0, 0, 255, 255); //
			yield return new WaitForSeconds(TimeCharge); //  
		}
		Charge = 0f; // 
		TypeIndexNeiron = _TypeIndexNeiron;// 
		ActionN = false;// 
		yield return new WaitForSeconds(TimeRepose);// 
		IgnoreInput = false;// 
		StartCoroutine ("EvaluationTime");// 
		if ((AdaptationTime > 0) && (thresholdTop > thresholdAdapt)) StartCoroutine ("AdaptationVoid");//
	}

	IEnumerator PlasticTimeCoruntine (Vector2 PT){//  
		CorunPlasticRun = true;//   
		float PlasticBuffer = Plasticity;//  
		Plasticity = PT.x;// 
		yield return new WaitForSeconds(PT.y);//  
		Plasticity = PlasticBuffer;//  
		CorunPlasticRun = false;//   
	}

	public void ActiveNeiron (){ //        
		if (!IgnoreInput)
		{
			if (TypeIndexNeiron == 0) StartCoroutine ("StartSummator");//  
			if (TypeIndexNeiron == 1) StartCoroutine ("StartModule");// 
			if (TypeIndexNeiron == 2) StartCoroutine ("StartAssociative");// ,    
			if (TypeIndexNeiron == 3) StartCoroutine ("StartWhite");//  
		}
	}

	private void Compass (){
		if (Area != null){ //    ,        
			VectorPattern = Vector3.zero; //  
            //  
			for (int i = 0; i < Area.GetComponent<AreaScript>().NeironActionList.Count; i++) { //   
				if (gameObject == Area.GetComponent<AreaScript> ().NeironActionList [i]) continue; //    
				Vector3 R = Area.GetComponent<AreaScript> ().NeironActionList [i].transform.position - transform.position;//  ,   
                //       
				VectorPattern += (Area.GetComponent<AreaScript> ().NeironActionList [i].GetComponent<NeironScript> ().Charge * R.normalized);//R.sqrMagnitude; .normalized   //sqrMagnitude;!!!!!!!!!(  )
			}

			if (VectorPattern.sqrMagnitude < 3f) VectorPattern = VectorTrend; //   ,    
			if (VectorPattern.sqrMagnitude == 0) VectorPattern = new Vector3(Random.Range(-1f, 1f), Random.Range(-1f, 1f), Random.Range(-1f, 1f)); 
            //   ( ),    ,    ,    - 

			VectorPattern.Normalize(); //   

            if (noveltyVector == Vector3.zero) noveltyVector = -VectorPattern; //  (   )    -    
			changeAngle = Vector3.Angle(VectorPattern, noveltyVector);//         

			if (Area != null) Area.SendMessage("MessageOriginality", changeAngle/180);//      

			VectorTrend = VectorPattern; // 
            noveltyVector = Vector3.Slerp(noveltyVector, VectorPattern, noveltyFactor);//  
            //      
            //        
            //   noveltyVector = VectorPattern,       (     )
            //       ,       
			gameObject.GetComponent<LineRenderer>().SetPosition(0, transform.position);//   
			gameObject.GetComponent<LineRenderer>().SetPosition(1, transform.position + VectorTrend * 6);

           
			if (PlasticityDinamic) {
				if (changeAngle < 10) Plasticity -= StepPlasticity; else Plasticity += StepPlasticity; // 
				if (Plasticity > 1) Plasticity = 1f;
				if (Plasticity < 0) Plasticity = 0f;
                //         
                //    ,         . 
                //..        ,       
			}

			if (FocusDinamic){
				if (changeAngle < 10) FocusNeiron -= StepFocus; else FocusNeiron = MaxFocus;
				if (FocusNeiron < 0) FocusNeiron = 0;
                //         .
                //        .
                //       .
                //   -     ,      
			}

            //  
			if (NewNeironDinamic){
                if (!Physics.CheckSphere(transform.position + VectorTrend * 5, 3f))
                {   //  -     3,
                    //     5   
                    //   
					if (Area.GetComponent<AreaScript>().Global) NewNeiron(); //    
					else 
					{
						if (Area.GetComponent<Collider>().bounds.Contains(transform.position + VectorTrend * 5)) NewNeiron(); //          
					}
				}

				//   
                Collider[] hitColliders = Physics.OverlapSphere(transform.position + VectorTrend * 5, 3f); //          
				foreach (Collider value in hitColliders) //    
				{
					if (value.tag == "Neiron") //  
					{
						bool EnableSinaps = false; //    
						foreach (GameObject sinapsValue in hitSinaps) //    
						{
							if (sinapsValue.GetComponent<SinapsScript>().NeironTarget == value.gameObject) {
								EnableSinaps = true; //   
								break; //  
							} 	
						}
						
						if (!EnableSinaps) { //   
							GameObject cSinaps = Instantiate(prefabSinaps, transform.position, transform.rotation) as GameObject;//   
							cSinaps.transform.parent = transform;
							cSinaps.GetComponent<SinapsScript>().NeironTarget = value.gameObject;
							cSinaps.GetComponent<SinapsScript>().Force = 0f;
							hitSinaps.Add(cSinaps);

						}

					}
				}
			}

			//        
			angleMin = 180f;
			if (hitSinaps.Count != 0) angleMin = Vector3.Angle(hitSinaps[0].GetComponent<SinapsScript>().NeironTarget.transform.position - transform.position, VectorTrend);
			foreach(GameObject ShershSinaps in hitSinaps)
			{
				float angleShersh = Vector3.Angle(ShershSinaps.GetComponent<SinapsScript>().NeironTarget.transform.position - transform.position, VectorTrend);
				if (angleShersh < angleMin) angleMin = angleShersh;
			}
           
			if (FocusNeiron < angleMin) FocusNeiron = angleMin;
            //      ,       .
            //        , 
            //        .

			//  
			foreach(GameObject SinapsCoeff in hitSinaps){
					if (SinapsCoeff.GetComponent<SinapsScript>().TypeSinaps == 0){
					    float angleSinaps = Vector3.Angle(SinapsCoeff.GetComponent<SinapsScript>().NeironTarget.transform.position - transform.position, VectorTrend);
					    if (angleSinaps <= FocusNeiron) SinapsCoeff.GetComponent<SinapsScript>().Force += MaxForceSinaps * Plasticity;
					    else SinapsCoeff.GetComponent<SinapsScript>().Force -= MaxForceSinaps * Plasticity;
					    SinapsCoeff.GetComponent<SinapsScript>().Force = Mathf.Clamp(SinapsCoeff.GetComponent<SinapsScript>().Force, 0, MaxForceSinaps);
				    }
			}
		}

		ExcitationTransfer ();//    
	}

	private void NewNeiron (){
		GameObject clone = Instantiate(prefabNeiron, transform.position + VectorTrend * 6, transform.rotation) as GameObject;
        /*  :        (   ),
         *      ,        
         *        ,     .
         *       ....
         * */
		if (Area != null) Area.GetComponent<AreaScript>().amount++;//     

		clone.GetComponent<NeironScript>().Plasticity = BasicPlasticity;//  
		clone.GetComponent<NeironScript>().ActionN = false;
		clone.GetComponent<NeironScript>().IgnoreInput = false;
		clone.GetComponent<NeironScript>().Adder = 0f;
		clone.GetComponent<NeironScript>().VectorTrend = Vector3.zero;
		clone.GetComponent<NeironScript>().Area = Area;
		clone.GetComponent<NeironScript>().TimeEvaluationBool = false;
		clone.GetComponent<NeironScript>().LimitEvaluationInt = 0;
		clone.GetComponent<NeironScript>().Charge = 0.0f; 
		clone.GetComponent<NeironScript>().FocusNeiron = MaxFocus;
		clone.GetComponent<NeironScript>().Plasticity =  BasicPlasticity;
		clone.GetComponent<NeironScript>().TypeIndexNeiron = 2;
        clone.GetComponent<NeironScript>().noveltyVector = Vector3.zero;
        clone.GetComponent<NeironScript>().VectorTrend = Vector3.zero;

		clone.GetComponent<LineRenderer>().SetPosition(0, clone.transform.position);
		clone.GetComponent<LineRenderer>().SetPosition(1, clone.transform.position);

		clone.SendMessage("StopNeiron"); //          ,   

		GameObject ManagerObj = GameObject.Find("Manager"); //... , Find   
		ManagerObj.GetComponent<ManagerScript>().EndIndexNeiron++;// 
		clone.GetComponent<NeironScript>().IndexNeiron = ManagerObj.GetComponent<ManagerScript>().EndIndexNeiron;//    
		clone.name = "Neiron" + clone.GetComponent<NeironScript>().IndexNeiron;//     

        foreach (GameObject sd in clone.GetComponent<NeironScript>().hitSinaps) Destroy(sd); //       ,     
		clone.GetComponent<NeironScript>().hitSinaps.Clear(); //   .  ..
	}

	void FixedUpdate(){ //      0.01


		if (!IgnoreInput) //    
		{
			if (TypeIndexNeiron == 0)  //    
			{
				if (Adder > thresholdTop) // 
				{
					StartCoroutine ("StartSummator"); 
				}
			}

			if (TypeIndexNeiron == 1) //  
			{
				if (Adder > thresholdTop + bonusThreshold) // 
				{
					
					if (TimeEvaluationBool) //  ?
					{                       
						LimitEvaluationInt++; // 
						StopCoroutine("EvaluationTime"); //    
						TimeEvaluationBool = false; //  
					}
					else LimitEvaluationInt = 0; //   

					if ((LimitEvaluationInt > LimitRecurrence) && (bonusThreshold == 0)) thresholdTop += thresholdTopUp; //         - 

					StopCoroutine ("AdaptationVoid");  // ,      
					StartCoroutine ("StartModule"); //    
					
				}

				if (Adder < thresholdDown) //    
				{
					if (Area != null) StartCoroutine ("repolarizationTime"); //   ,    
				}
			}

			if (TypeIndexNeiron == 2) // 
			{
				if (Adder > thresholdTop + bonusThreshold) //    :   
				{
					if (TimeEvaluationBool) //     
					{
						LimitEvaluationInt++; //  
						StopCoroutine("EvaluationTime");//  
						TimeEvaluationBool = false;
					}
					else LimitEvaluationInt = 0; //   ,  

					if ((LimitEvaluationInt > LimitRecurrence) && (bonusThreshold == 0)) thresholdTop += thresholdTopUp; //      ,    

					StopCoroutine ("AdaptationVoid");// ,   ( -    )
					StartCoroutine ("StartAssociative"); //    
				}

				if (Adder < thresholdDown) //   
				{
					StartCoroutine ("NegativeRepolarization");  //  ()
				}
			}

			if (TypeIndexNeiron == 3) //  
			{
				if (Adder > thresholdTop + bonusThreshold)//   
				{
					if (TimeEvaluationBool)// ...
					{
						LimitEvaluationInt++;
						StopCoroutine("EvaluationTime");
						TimeEvaluationBool = false;
					}
					else LimitEvaluationInt = 0;

					if ((LimitEvaluationInt > LimitRecurrence) && (bonusThreshold == 0)) thresholdTop += thresholdTopUp;

					StopCoroutine ("AdaptationVoid");
					StartCoroutine ("StartWhite");  
				}

				if (Adder < thresholdDown)
				{
					StartCoroutine ("NegativeRepolarization");  
				}
			}

		}

        if (Mathf.Abs(Adder) <= DampferAdder) Adder = 0f; // 
		if (Adder > DampferAdder) Adder -= DampferAdder;
		if (Adder < -DampferAdder) Adder += DampferAdder;

        if (Mathf.Abs(bonusThreshold) <= DempferBonusThreshold) bonusThreshold = 0f; //  
		if (bonusThreshold > DempferBonusThreshold) bonusThreshold -= DempferBonusThreshold;
		if (bonusThreshold < -DempferBonusThreshold) bonusThreshold += DempferBonusThreshold;
	} 

	private void ExcitationTransfer () // 
	{
		foreach (GameObject value in hitSinaps) //   
		{
			int T = value.GetComponent<SinapsScript>().TypeSinaps; // 
			float F = value.GetComponent<SinapsScript>().Force; // 
			GameObject NT = value.GetComponent<SinapsScript>().NeironTarget;// 
			if (T == 0) NT.SendMessage("AddSummator", F);// 
			if (T == 1) NT.SendMessage("AddTActual", F);
			if (T == 2) NT.SendMessage("ActiveNeiron");
            if (T == 3) NT.SendMessage("AddSummator", F);
			value.GetComponent<SinapsScript>().GoAction = true;//  
		}
	}

	public void AddSummator (float Summ) //      
	{
		Adder += Summ;
		if (Adder > MaxAdder) Adder = MaxAdder;
        if (Adder < - MaxAdder) Adder = -MaxAdder;
	}

	public void AddTActual (float T)//  ,  
	{
		bonusThreshold += T;
		if (bonusThreshold + thresholdTop < 0f) bonusThreshold = - thresholdTop + 0.0001f;
	}

	public void StopNeiron(){//  ,     GameOject.SendMessage("StopNeiron") 
		StopAllCoroutines();
	}

	public void plasticSetTime (Vector2 plasticTime){
        //  , SendMessage     , Vectir2 -    
        //     
		if (!CorunPlasticRun) StartCoroutine("PlasticTimeCoruntine", plasticTime);
        if (TypeIndexNeiron == 2) thresholdTop = thresholdAdapt;
	}
}



La communication entre les neurones est effectuée à l'aide d'un système de messages, basé sur SendMessage, et tous les processus associés aux changements d'état sont effectués dans des coroutines.



Dans le diagramme, la base de base du neuroélément. SendMessage («AddSummator», F) - synapse à action directe avec force F, augmente la somme de l'additionneur d'un nombre donné. Toutes les 0,01 s, la fonction FixedUpdate () est activée dans laquelle le modulateur de l'additionneur diminue du registre / nombre défini. Et il y a aussi une vérification que le seuil est dépassé sur l'additionneur, si le seuil est dépassé, alors coruntin est démarré. Pendant la période de fonctionnement corindon, le mode d'ignorance des signaux externes est activé, mais l'amortisseur pour l'additionneur continue ainsi que la possibilité de reconstituer la quantité. SendMessage («ActiveNeiron») - contact synapse (efaps), la coroutine sera lancée si elle n'est pas en cours d'exécution sinon le signal sera ignoré.

Sur cette base, des mécanismes liés au métabolisme cellulaire (dépendance et adaptation), ainsi qu'un système de modulation, dérivé des travaux d'Eric Kandel, ont été ajoutés. Et l'idée de transmission directionnelle d'excitation dans un souci de vérification dont j'ai commencé ce projet.

Beaucoup étaient intéressés par le code source du projet, mais pas seulement pour cette raison, je poste la source. Le fait est qu'il reste encore beaucoup de travail à faire, prévoit d'étendre sérieusement les capacités et les outils, de créer une sorte d'environnement qui vous permet de travailler facilement avec un large éventail d'éléments, de les structurer et de les organiser. Je n'ai pas beaucoup d'expérience en programmation, mais je suis sûr qu'un grand nombre de personnes de la communauté GeekTimes peuvent donner des recommandations sur la structure, les méthodes et les optimisations qui amélioreront qualitativement le projet. Je prévois de ne pas changer l'environnement de développement, les données empiriques du processus de développement sont importantes pour moi, ainsi que l'esthétique du résultat final et le moteur de jeu Unity jusqu'à présent m'ont très bien aidé dans ce domaine.

Source: https://habr.com/ru/post/fr398867/

More articles:


All Articles