Geekly articles weekly

Neuroelement-Code



Hallo liebe GeekTimes Community! Vor nicht allzu langer Zeit wurde hier eine Reihe von Artikeln veröffentlicht, die sich mit der Arbeit an einem Modell des Nervensystems befassen. Der beste Weg, um die Logik des Modells zu verstehen, besteht darin, den Programmcode für seine Implementierung zu studieren. Ich möchte nicht nur meine Ideen detaillierter vermitteln, sondern auch die Community um Hilfe bitten. Ich weiß, dass es unter GT-Lesern viele Fachleute auf dem Gebiet des Schreibens von Software-Code gibt, und Ihre Erfahrung, Wissen, kann bei der Entwicklung des Projekts helfen. Manchmal reichen kompetente Ratschläge oder Empfehlungen aus, um die Lösung einer solchen ungewöhnlichen Aufgabe elegant und einfach zu gestalten.

Inhaltszyklus
1. . 1.
2. . 2.
3. . 3.
4. ,
5.
6.
7.

Die Entwicklungsumgebung ist Unity3D, eine sehr beliebte Spiel-Engine. Diese Umgebung erwies sich sowohl in Zusammenarbeit mit dem Herausgeber als auch in Gegenwart einer Vielzahl von Referenzen, Erklärungen und Kommentaren in russischer Sprache als sehr praktisch und zugänglich. Daher reichten meine bescheidenen Programmierkenntnisse aus, um meine Ideen mit Unity3D umzusetzen.

Die Pläne ändern nichts an der Entwicklungsumgebung, da die Spiel-Engine die Lösung von Visualisierungsproblemen erleichtert, was in dieser Phase sehr wichtig ist.

Ich möchte mich bei denen entschuldigen, die sich wegen ihrer Nachlässigkeit, möglichen Vernachlässigung der Sprachsyntax und möglicher Fehler an den Code wenden möchten. Als ich mit dieser Arbeit anfing, war in den Plänen keine Code-Demonstration enthalten. Ich wollte einige meiner Hypothesen testen.

Der Code spiegelt eine kreative Suche wider. Während der Arbeit stand ich vor einem anderen Problem, das Modell wollte nicht so handeln, wie ich es mir vorgestellt hatte. Und tagsüber könnte mir die Idee kommen, wie ich das beheben kann. In diesen Momenten kann ich mich von einer Art Einsicht inspirieren lassen. Als ich von der Arbeit zurückkam, nahm ich eifrig Korrekturen vor und ignorierte alle Regeln im Code. Dafür war keine Zeit. Und wie oft dies passiert, haben diese Erkenntnisse keine Ergebnisse gebracht oder nicht das gewünschte Ergebnis gebracht. Also ging die Arbeit an dem Projekt weiter und danke für die Geduld meiner Frau, die es mir ermöglichte, diese Arbeit durchzuführen. Es ist schwierig, Zeit zwischen Familie, Arbeit, Ihrem eigenen Aufschub und Faulheit bei der Routinearbeit der Codestandardisierung zu finden. Obwohl es eines Tages noch getan werden muss.

In meiner Arbeit hielt ich an einem etwas ungewöhnlichen Modell des Neurons fest. Ein Neuronenmodell könnte wie ein biologisches Neuron asynchron von der Arbeit anderer Neuronen handeln. Signale von Rezeptorschlüsseln, z. B. von Hautrezeptoren, können möglicherweise nicht synchronisiert werden. Daher habe ich in den ersten Modellen unter dem Einfluss stereotypen Denkens bestimmte Phasen des Zustands im Neuron herausgegriffen, die eine bestimmte Anzahl von Schritten (Zyklen) des gesamten Systems dauern, und die Schritte des Systems wurden in allen Neuronen synchron ausgeführt. Dies funktionierte nicht richtig und es war schrecklich unangenehm. Es war jedoch notwendig, die eingehenden und ausgehenden Signale irgendwie zu synchronisieren und korrekt auszuwerten.

Zu einem bestimmten Zeitpunkt kam die Idee, dass ein Internetnutzer später den "Ablauftank" nannte. Das Modell „Drain Tank“ erwies sich als überraschend genau und auf ein biologisches Neuron anwendbar. Es erklärte die Summierungsmechanismen sehr deutlich und war bequemer zu implementieren. Jetzt könnten emulierte Neuronen völlig unabhängig sein, genau wie reale Objekte.



Dieses Addierermodell ist das genaueste biologische Neuronenmodell, das ich kenne. Um eine Magenzelle im Detail zu simulieren, ist eine unglaublich große Verarbeitungsleistung erforderlich. Diese Zelle produziert jedoch nur das entsprechende Enzym oder Hormon, falls erforderlich. Die Zuordnung unglaublicher rechnerischer Eigenschaften zu einem Neuron ist in der modernen Kybernetik sehr beliebt.

Anschließend wurden dem Summationsmodell einige Mechanismen aus der Reflextheorie und der Idee der Richtungsorientierung der Einstellungen für die ausgehende Synapsenleistung hinzugefügt. Das resultierende Modell ermöglichte es, eine theoretische Grundlage zu schaffen, die ganz einfach viele Prozesse und Phänomene erklärte, die im Nervensystem auftreten. Reflexmechanismen, Gedächtnis und Gedächtniskonsolidierung, Selbstorganisation und Spezialisierung von Neuronen, Kleinhirnarbeit, emotionale Mechanismen und Denken sind alles in einer Flasche.

Ich werde nicht langweilen. Link zum GitHub-Repository .

Zum Beispiel der Skriptcode, der die Hauptlogik der Operation des neuronalen Elements NeironScript.cs enthält (Entschuldigung für mein Französisch):

Viel 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;
	}
}



Die Kommunikation zwischen Neuronen erfolgt über ein Nachrichtensystem, das auf SendMessage basiert, und alle mit Statusänderungen verbundenen Prozesse werden in Coroutinen ausgeführt.



Im Blockschaltbild die Basis des Neuroelements. SendMessage ("AddSummator", F) - direkt wirkende Synapse mit Kraft F, erhöht die Summe des Addierers um eine bestimmte Zahl. Alle 0,01 s wird die Funktion FixedUpdate () aktiviert, bei der der Modulator des Addierers um den eingestellten Dämpfer / die eingestellte Zahl abnimmt. Außerdem wird überprüft, ob der Schwellenwert auf dem Addierer überschritten wird. Wenn der Schwellenwert überschritten wird, wird die Coruntine gestartet. Während des Korundbetriebs ist der Modus zum Ignorieren externer Signale aktiviert, aber der Dämpfer für den Addierer bleibt bestehen und es besteht die Möglichkeit, den Betrag wieder aufzufüllen. SendMessage ("ActiveNeiron") - Kontaktsynapse (efaps), Coroutine wird gestartet, wenn sie derzeit nicht ausgeführt wird, andernfalls wird das Signal ignoriert.

Auf dieser Basis wurden Mechanismen im Zusammenhang mit dem Zellstoffwechsel (Sucht und Anpassung) sowie ein Modulationssystem, das aus der Arbeit von Eric Kandel abgeleitet wurde, hinzugefügt. Und die Idee der gerichteten Übertragung von Anregung, zu deren Überprüfung ich dieses Projekt gestartet habe.

Viele interessierten sich für den Quellcode des Projekts, aber nicht nur aus diesem Grund poste ich den Quellcode. Tatsache ist, dass noch viel Arbeit vor uns liegt, die Funktionen und Tools ernsthaft erweitert werden sollen und eine Art Umgebung geschaffen werden soll, in der Sie bequem mit einer Vielzahl von Elementen arbeiten, diese strukturieren und organisieren können. Ich habe nicht viel Programmiererfahrung, aber ich bin sicher, dass eine große Anzahl von Leuten aus der GeekTimes-Community Empfehlungen zu Struktur, Methoden und Optimierungen geben kann, die das Projekt qualitativ verbessern. Ich habe vor, die Entwicklungsumgebung nicht zu ändern. Die empirische Darstellung des Entwicklungsprozesses ist für mich wichtig, ebenso wie die Ästhetik des Endergebnisses und die Unity-Spiel-Engine, die mir bisher sehr geholfen haben.

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

More articles:


All Articles