def getSynapticRisePerturbationVariable(self,_PerturbationComplex): #debug ''' self.debug( [ ('self.',self,[ 'StabilizedDecayTimeVariable', ]), '_PerturbationComplex is '+str(_PerturbationComplex) ] ) ''' #return return SYS.setMatrixArray( SYS.setMatrixArray( self.getSynapticDelayPerturbationVariable(_PerturbationComplex), 1.+self.StabilizedDecayTimeVariable*_PerturbationComplex, np.ndarray.__div__, _AxisInt=1 ), 1.+self.StabilizedRiseTimeVariable*_PerturbationComplex, np.ndarray.__div__, _AxisInt=1 )
def getSynapticDelayPerturbationVariable(self,_PerturbationComplex): #debug ''' self.debug( [ ('self.',self,[ 'StabilizedDelayTimeVariable' ]), '_PerturbationComplex is '+str(_PerturbationComplex) ] ) ''' #return return SYS.setMatrixArray( np.ones( (self.StationarizingUnitsInt,self.StationarizingUnitsInt), dtype=complex ), np.exp( -self.StabilizedDelayTimeVariable*_PerturbationComplex ), np.ndarray.__mul__, _AxisInt=1 )
def setStabilizedFlatPerturbationComplexesArray(self): #call self.setStabilizedTotalPerturbationComplexesArray() #/###############/# # multiply all by the LeakNeuralPerturbationVariable # #get the numerator leak term StabilizedLeakNeuralPerturbationVariable=self.getLeakNeuralPerturbationComplex( self.StabilizedPerturbationComplex ) #mul self.StabilizedFlatTotalPerturbationComplexesArray=SYS.setMatrixArray( self.StabilizedTotalPerturbationComplexesArray.T, StabilizedLeakNeuralPerturbationVariable, np.ndarray.__mul__ ).T #debug '''
def do_numscipy( self ): #debug ''' self.debug( [ 'We numscipy here', ('self.',self,[ 'NumscipyingValueVariable', 'NumscipiedValueFloatsArray' ]) ] ) ''' #/#################/# # Set the size of the matrix # #Check if type(self.NumscipyingValueVariable)==None.__class__: #debug ''' self.debug( [ 'This is an array that we have to build' ] ) ''' #set if self.NumscipyingSizeTuple==None or len(self.NumscipyingSizeTuple)==0 : #set self.NumscipyingSizeTuple=( self.NumscipyingRowsInt, self.NumscipyingColsInt ) else: #set self.NumscipyingRowsInt=self.NumscipyingSizeTuple[0] self.NumscipyingColsInt=self.NumscipyingSizeTuple[1] #init self.NumscipiedValueFloatsArray=None else: #debug ''' self.debug( [ 'This is an array already built' ] ) ''' #set self.NumscipyingSizeTuple=np.shape( self.NumscipyingValueVariable ) self.NumscipyingRowsInt=self.NumscipyingSizeTuple[0] self.NumscipyingColsInt=self.NumscipyingSizeTuple[1] #alias self.NumscipiedValueFloatsArray=self.NumscipyingValueVariable #debug ''' self.debug( [ 'We have setted the shape of the matrix', ('self.',self,['NumscipyingSizeTuple']) ] ) ''' #/#################/# # Build maybe # #Check if type(self.NumscipyingValueVariable)==None.__class__: #/#################/# # Set maybe the seed # #check if self.NumscipyingSeedVariable!=None: #seed np.random.seed(self.NumscipyingSeedVariable) #debug ''' self.debug( [ "We have fixed a seed", ('self.',self,[ 'NumscipyingSeedVariable' ]) ] ) ''' #/#################/# # Get the continuous stat # #Check if self.NumscipyingStdFloat>0.: #import import scipy.stats #get self.NumscipiedContinuousStatRigidFunction=getattr( scipy.stats, self.NumscipyingContinuousStatStr )( self.NumscipyingMeanFloat, self.NumscipyingStdFloat ).rvs #/#################/# # Get the discrete stat # #Check if self.NumscipyingSparseFloat>0. and self.NumscipyingSparseFloat<1.: #debug ''' self.debug( [ 'We numscipy here', 'We set a discrete skeleton', ('self.',self,[ 'NumscipyingDiscreteStatStr', 'NumscipyingSparseFloat' ]) ] ) ''' #/#################/# # Get a list of one or zero # #import import scipy.stats #get self.NumscipiedDiscreteStatRigidFunction=getattr( scipy.stats, self.NumscipyingDiscreteStatStr ).rvs #prod NumscipiedSizeInt=np.prod(self.NumscipyingSizeTuple) #set NumscipiedRandomIntsArray=self.NumscipiedDiscreteStatRigidFunction( self.NumscipyingSparseFloat, size=NumscipiedSizeInt ) #/#################/# # Maybe set a continuous stat for non zero values # #debug self.debug( [ ('self.',self,[ 'NumscipiedContinuousStatRigidFunction' ]) ] ) #map if self.NumscipiedContinuousStatRigidFunction!=None: #Check self.NumscipiedValueFloatsArray=np.array( map( lambda __IndexInt,__BoolInt: self.NumscipiedContinuousStatRigidFunction() if __BoolInt==1 else 0., xrange(NumscipiedSizeInt), NumscipiedRandomIntsArray, ) ) else: #just floatify self.NumscipiedValueFloatsArray=self.NumscipyingMeanFloat*np.array( map( float, NumscipiedRandomIntsArray ) ) #reshape self.NumscipiedValueFloatsArray=self.NumscipiedValueFloatsArray.reshape( self.NumscipyingSizeTuple ) #Check if self.NumscipyingSwitchFloat>0.: #/##################/# # Switch the sgn # #debug ''' self.debug( [ 'We switch the sign', ('self.',self,[ 'NumscipyingSwitchFloat' ]) ] ) ''' #import import itertools #filter the upper index tuples self.NumscipiedIndexIntsTuplesList=filter( lambda __Tuple: __Tuple[1]!=__Tuple[0], itertools.product( xrange(self.NumscipyingColsInt), xrange(self.NumscipyingColsInt) ) ) #/#################/# # group by the null and non null index tuples # #filter [ self.NumscipiedNonNullIndexIntsTuplesList, self.NumscipiedNullIndexIntsTuplesList ]=SYS.groupby( lambda __IndexIntsTuple: self.NumscipiedValueFloatsArray[ __IndexIntsTuple ]!=0., self.NumscipiedIndexIntsTuplesList ) #len NumscipiedSwitchsInt=int(self.NumscipyingSwitchFloat*len( self.NumscipiedNonNullIndexIntsTuplesList ) ) #copy self.NumscipiedToSwitchIndexIntsTuplesList=self.NumscipiedNonNullIndexIntsTuplesList[:] #debug ''' self.debug( [ 'Before shuffle to switch', ('self.',self,[ 'NumscipiedToSwitchIndexIntsTuplesList' ]), ] ) ''' #Shuffle and pick the NumscipiedToSwitchIndexIntsTuplesList np.random.shuffle( self.NumscipiedToSwitchIndexIntsTuplesList ) #cut self.NumscipiedToSwitchIndexIntsTuplesList=self.NumscipiedToSwitchIndexIntsTuplesList[ :NumscipiedSwitchsInt ] #debug ''' self.debug( [ 'We map switch here', ('self.',self,[ 'NumscipiedToSwitchIndexIntsTuplesList' ]), 'NumscipiedSwitchsInt is '+str(NumscipiedSwitchsInt) ] ) ''' #map switch map( lambda __NumscipiedToSwitchIndexIntsTuple: self.NumscipiedValueFloatsArray.__setitem__( __NumscipiedToSwitchIndexIntsTuple, -self.NumscipiedValueFloatsArray[ __NumscipiedToSwitchIndexIntsTuple ] ), self.NumscipiedToSwitchIndexIntsTuplesList ) #/#################/# # If it is a dense matrix then # set direct all the matrix #Check if type(self.NumscipiedValueFloatsArray)==None.__class__: #debug ''' self.debug( [ 'This is a random norm distribution', ('self.',self,[ 'NumscipyingMeanFloat', 'NumscipyingStdFloat', 'NumscipiedContinuousStatRigidFunction' ]) ] ) ''' #Check if self.NumscipiedContinuousStatRigidFunction!=None: #set self.NumscipiedValueFloatsArray=self.NumscipiedContinuousStatRigidFunction( size=self.NumscipyingSizeTuple ) else: #set self.NumscipiedValueFloatsArray=self.NumscipyingMeanFloat*np.ones( self.NumscipyingSizeTuple ) #debug ''' self.debug( [ 'at this step', ('self.',self,[ 'NumscipiedValueFloatsArray', 'NumscipyingMeanFloat' ]) ] ) ''' #/#################/# # Normalize maybe # #debug ''' self.debug( [ 'Do we have to normalize', ('self.',self,[ 'NumscipyingDivideVariable', 'NumscipyingNormalisationFunction' ]) ] ) ''' #Check if self.NumscipyingDivideVariable!=None: #divide self.NumscipiedValueFloatsArray=( self.NumscipiedValueFloatsArray.T/self.NumscipyingDivideVariable ).T #Check if self.NumscipyingNormalisationFunction!=None and len( self.NumscipyingSizeTuple) and self.NumscipyingSizeTuple[0]==self.NumscipyingSizeTuple[1]: #set self.NumscipiedNormVariable=self.NumscipyingNormalisationFunction( self.NumscipyingSizeTuple[0] ) #debug ''' self.debug( [ 'We normalize with', 'NumscipiedNormVariable is', str(NumscipiedNormVariable), ('self.',self,[ 'NumscipyingStdFloat' ]) ] ) ''' #normalize self.NumscipiedValueFloatsArray/=self.NumscipiedNormVariable #/#################/# # Symmetrize maybe # #set NumscipiedShiftSymmetryFloat=0.5*(self.NumscipyingSymmetryFloat+1.) #compute self.NumscipiedSymmetricsInt=( self.NumscipyingColsInt*(self.NumscipyingColsInt-1) ) #Check if self.NumscipyingSymmetryFloat!=0.: #debug ''' self.debug( [ 'We are going to symmetrize', ('self.',self,[ 'NumscipyingSymmetryFloat' ]) ] ) ''' #Check if self.NumscipyingSparseFloat==0. and self.NumscipyingStdFloat>0.: #/#################/# # This is a dense symmetrization # #debug ''' self.debug( [ 'We do a dense symmetrization' ] ) ''' #import import itertools #copy NumscipiedValueFloatsArray=self.NumscipiedValueFloatsArray[:] #build the scale factor """ #ERWAN version NumscipiedScaleFloat=( ( self.NumscipyingSymmetryFloat-1. )*0.5 )+1 #Build a more or less DisSymmetricRandomArray self.NumscipiedValueFloatsArray=2.*( (NumscipiedScaleFloat/2.)*(NumscipiedValueFloatsArray+NumscipiedValueFloatsArray.T) +(0.5-(NumscipiedScaleFloat/2.))*(NumscipiedValueFloatsArray-NumscipiedValueFloatsArray.T) ) """ #CELIAN version #compute NumscipiedScaleFloat = np.sqrt( NumscipiedShiftSymmetryFloat**2-NumscipiedShiftSymmetryFloat+0.5 ) #compute the anti-symm martix self.NumscipiedValueFloatsArray = ( NumscipiedShiftSymmetryFloat * ( NumscipiedValueFloatsArray + NumscipiedValueFloatsArray.T )/2. + (1.-NumscipiedShiftSymmetryFloat) * ( NumscipiedValueFloatsArray - NumscipiedValueFloatsArray.T )/2. ) / NumscipiedScaleFloat #fill diagonal np.fill_diagonal( NumscipiedValueFloatsArray, np.diagonal(self.NumscipiedValueFloatsArray) ) elif self.NumscipyingSparseFloat>0.: #/#################/# # This is a sparse symmetrization # #debug ''' self.debug( [ 'We do a targeted symmetrization', 'First we keep only the upper part and triangularize', ('self.',self,[ 'NumscipyingSymmetryFloat', 'NumscipiedSymmetricsInt' ]) ] ) ''' #triu self.NumscipiedValueFloatsArray=np.triu( self.NumscipiedValueFloatsArray ) self.NumscipiedValueFloatsArray=self.NumscipiedValueFloatsArray+( 1. if self.NumscipyingSymmetryFloat>=0. else -1. )*self.NumscipiedValueFloatsArray.T-np.diag( np.diagonal( self.NumscipiedValueFloatsArray ) ) #Check if self.NumscipiedIndexIntsTuplesList==None: #import import itertools #filter the upper index tuples self.NumscipiedIndexIntsTuplesList=filter( lambda __Tuple: __Tuple[1]!=__Tuple[0], itertools.product( xrange(self.NumscipyingColsInt), xrange(self.NumscipyingColsInt) ) ) #/#################/# # group by the null and non null index tuples # #filter [ self.NumscipiedNonNullIndexIntsTuplesList, self.NumscipiedNullIndexIntsTuplesList ]=SYS.groupby( lambda __IndexIntsTuple: self.NumscipiedValueFloatsArray[ __IndexIntsTuple ]!=0., self.NumscipiedIndexIntsTuplesList ) #debug ''' self.debug( [ 'Now', ('self.',self,[ 'NumscipiedNonNullIndexIntsTuplesList' ]) ] ) ''' #/#################/# # This is a sparse targeting symmetrization # #debug ''' self.debug( [ 'Ok we have built a sparse symmetric matrix', 'We are going to dissymetrize by picking index tuples', 'For now, we have just kept the upper values', ('self.',self,[ 'NumscipiedIndexIntsTuplesList' ]), 'We are just going to pick the non null values', ] ) ''' #/#################/# # determine a shuffle list of pair to dissymetrize # #int self.NumscipiedToDissymetricsInt=(int)( (1.-abs(self.NumscipyingSymmetryFloat))*len( self.NumscipiedNonNullIndexIntsTuplesList ) )/2 #copy self.NumscipiedToDissymetrizeIndexIntsTuplesList=self.NumscipiedNonNullIndexIntsTuplesList[:] #debug ''' self.debug( [ 'Before shuffle', ('self.',self,[ 'NumscipiedToDissymetrizeIndexIntsTuplesList' ]), 'We take the half of self.NumscipiedToDissymetricsInt for the targetting case' ] ) ''' #Shuffle and pick the self.NumscipiedToDissymetricsInt/2 np.random.shuffle(self.NumscipiedToDissymetrizeIndexIntsTuplesList) self.NumscipiedToDissymetrizeIndexIntsTuplesList=self.NumscipiedToDissymetrizeIndexIntsTuplesList[ :(self.NumscipiedToDissymetricsInt/2) ] if self.NumscipyingStdFloat==0 else self.NumscipiedToDissymetrizeIndexIntsTuplesList[ :self.NumscipiedToDissymetricsInt ] #debug ''' self.debug( [ 'in the end', ('self.',self,[ #'NumscipiedNonNullIndexIntsTuplesList', 'NumscipiedToDissymetrizeIndexIntsTuplesList', #'NumscipiedNullIndexIntsTuplesList', 'NumscipiedToDissymetricsInt' ]), 'len(self.NumscipiedNonNullIndexIntsTuplesList) is ', str(len(self.NumscipiedNonNullIndexIntsTuplesList)), ] ) ''' #/#################/# # prepare the other list of null tuples # in which we are going to transform #map self.NumscipiedNullIndexIntsListsList=map( lambda __IndexInt: [], xrange(self.NumscipyingColsInt) ) #map map( lambda __NumscipiedNullIndexIntsTuple: self.NumscipiedNullIndexIntsListsList[ __NumscipiedNullIndexIntsTuple[0] ].append( __NumscipiedNullIndexIntsTuple[1] ), self.NumscipiedNullIndexIntsTuplesList ) #debug ''' self.debug( [ ('self.',self,[ 'NumscipiedNullIndexIntsListsList' ]) ] ) ''' #/#################/# # Now setSymmmetrize for each ToDissymetrize # #map self.NumscipiedIsDisymmetrizeIndexIntsListsList=map( lambda __IndexInt: [], xrange(self.NumscipyingColsInt) ) #init self.NumscipiedIsDissymetricsInt=0 #set self.NumscipiedDissymetryFunction=(lambda : 0.) if self.NumscipyingStdFloat==0. else ( (lambda : self.NumscipiedContinuousStatRigidFunction()/self.NumscipiedNormVariable) if self.NumscipiedNormVariable!=None else self.NumscipiedContinuousStatRigidFunction ) #debug ''' self.debug( [ 'before setDisymmetrize', ('self.',self,[ 'NumscipiedDissymetryFunction' ]) ] ) ''' #map map( lambda __NumscipiedToDissymetrizeIndexIntsTuple: self.setDisymmetrize( __NumscipiedToDissymetrizeIndexIntsTuple ), self.NumscipiedToDissymetrizeIndexIntsTuplesList ) #debug ''' self.debug( [ 'In the end', ('self.',self, [ 'NumscipiedToDissymetricsInt', 'NumscipiedToDissymetrizeIndexIntsTuplesList', 'NumscipiedIsDisymmetrizeIndexIntsListsList', 'NumscipiedIsDissymetricsInt', ] ) ] ) ''' #/#################/# # Maybe set a specific diagonal # #Check if type(self.NumscipyingDiagFloatsArray)!=None.__class__ and len( self.NumscipyingDiagFloatsArray)==np.shape( self.NumscipiedValueFloatsArray )[0]: #debug ''' self.debug(('self.',self,['NumscipyingDiagFloatsArray'])) ''' #map ''' map( lambda __RowInt,__NumscipyingDiagFloat: self.NumscipiedValueFloatsArray.__setitem__( (__RowInt,__RowInt), __NumscipyingDiagFloat ), xrange(len(self.NumscipiedValueFloatsArray)), self.NumscipyingDiagFloatsArray ) ''' #fill diagonal np.fill_diagonal( self.NumscipiedValueFloatsArray, np.diagonal(self.NumscipyingDiagFloatsArray) ) #/#################/# # Force maybe the sum of the rows or the cols to be the same # #Check if self.NumscipyingMeanForceStr!="None": #debug """ self.debug( [ ('We force the ' + self.NumscipyingMeanForceStr + ' to be the same'), ('self.',self,[ 'NumscipyingMeanFloat', 'NumscipiedValueFloatsArray' ]) ] ) """ #Check if self.NumscipyingMeanForceStr=="rows": SumAxisInt=1 SetAxisInt=0 elif self.NumscipyingMeanForceStr=="cols": SumAxisInt=0 SetAxisInt=1 #compute NumscipiedResiduFloatsArray = np.sum( self.NumscipiedValueFloatsArray, axis = SumAxisInt, ) - self.NumscipyingMeanFloat #debug """ self.debug( [ "NumscipiedResiduFloatsArray is "+str(NumscipiedResiduFloatsArray) ] ) """ #set SYS.setMatrixArray( self.NumscipiedValueFloatsArray, - NumscipiedResiduFloatsArray/float(self.NumscipyingColsInt), _SetMethod=np.ndarray.__add__, _AxisInt=SetAxisInt ) #/#################/# # Compute statistic # #debug ''' self.debug( [ 'Do we compute statistics on the matrix ?', ('self.',self,[ 'NumscipyingStatBool', 'NumscipyingRowsInt', 'NumscipyingColsInt' ]), 'self.NumscipyingRowsInt==self.NumscipyingColsInt is '+str( self.NumscipyingRowsInt==self.NumscipyingColsInt ) ] ) ''' #Check if self.NumscipyingStatBool and self.NumscipyingRowsInt==self.NumscipyingColsInt: #import import itertools #debug ''' self.debug( [ 'We compute the variance', ('self.',self,[ 'NumscipiedSymmetricsInt' ]) ] ) ''' #list NumscipiedLateralIndexIntsList=list( itertools.product( xrange(self.NumscipyingRowsInt), xrange(self.NumscipyingColsInt) ) ) #variance self.NumscipiedMeanFloat=np.sum( np.array( filter( lambda __Float: __Float!=None, map( lambda __Tuple: self.NumscipiedValueFloatsArray[__Tuple] if __Tuple[0]!=__Tuple[1] else None , NumscipiedLateralIndexIntsList ) ) ) )/(float(self.NumscipiedSymmetricsInt)) #debug ''' self.debug( [ ('self.',self,[ 'NumscipiedMeanFloat' ]) ] ) ''' #variance self.NumscipiedVarianceFloat=np.sum( np.array( filter( lambda __Float: __Float!=None, map( lambda __Tuple: ( self.NumscipiedValueFloatsArray[__Tuple]-self.NumscipiedMeanFloat )**2 if __Tuple[0]!=__Tuple[1] else None ,NumscipiedLateralIndexIntsList ) ) ) )/(float(self.NumscipiedSymmetricsInt-1)) #set self.NumscipiedSommersFloat = ( 2.*NumscipiedShiftSymmetryFloat-1. )/( 2.*NumscipiedShiftSymmetryFloat*( NumscipiedShiftSymmetryFloat-1. )+1. ) #Check if self.NumscipyingStdFloat==0.: #mul self.NumscipiedSommersFloat*=self.NumscipyingSparseFloat*( 1.-self.NumscipyingSparseFloat ) #debug ''' self.debug( [ 'NumscipiedShiftSymmetryFloat is '+str(NumscipiedShiftSymmetryFloat), ('self.',self, [ 'NumscipyingSparseFloat', 'NumscipiedVarianceFloat', 'NumscipiedSommersFloat', 'NumscipiedSymmetricsInt' ] ) ] ) ''' #deviation self.NumscipiedStdFloat=np.sqrt(self.NumscipiedVarianceFloat) #covariance self.NumscipiedCovarianceFloat=self.NumscipyingColsInt*np.sum( np.array( filter( lambda __Float: __Float!=None, map( lambda __Tuple: ( self.NumscipiedValueFloatsArray[__Tuple]-self.NumscipiedMeanFloat )*( self.NumscipiedValueFloatsArray[(__Tuple[1],__Tuple[0])]-self.NumscipiedMeanFloat ) if __Tuple[0]!=__Tuple[1] else None ,NumscipiedLateralIndexIntsList ) ) ) )/( float( self.NumscipiedSymmetricsInt-1 ) ) #debug ''' self.debug( [ 'We compute the center', ('self.',self,[ 'NumscipyingSwitchFloat', 'NumscipyingMeanFloat' ]) ] ) ''' #compute the center self.NumscipiedCenterFloat=( self.NumscipyingSwitchFloat*self.NumscipyingMeanFloat-( 1.-self.NumscipyingSwitchFloat )*self.NumscipyingMeanFloat)/2. #set self.NumscipiedWidthFloat=2.*(1.+self.NumscipiedSommersFloat) self.NumscipiedHeightFloat=2.*(1.-self.NumscipiedSommersFloat) #Check if self.NumscipyingStdFloat>0.: #mul self.NumscipiedWidthFloat*=self.NumscipyingStdFloat self.NumscipiedHeightFloat*=self.NumscipyingStdFloat else: #sqrt self.NumscipiedStdSparseFloat=np.sqrt( self.NumscipyingSparseFloat*( 1.-self.NumscipyingSparseFloat) ) #mul self.NumscipiedWidthFloat*=self.NumscipiedStdSparseFloat self.NumscipiedHeightFloat*=self.NumscipiedStdSparseFloat #/#################/# # Get the eigenvalues # #Check if self.NumscipyingEigenvectorBool: pass #Check if self.NumscipyingEigenvalueBool: #debug ''' self.debug( [ 'We compute the eigenvalues', ('self.',self,[ 'NumscipiedValueFloatsArray' ]) ] ) ''' #Check if self.NumscipyingSymmetryFloat==1.: #compute self.NumscipiedEigenvalueComplexesArray=np.linalg.eigvalsh( self.NumscipiedValueFloatsArray ) else: #compute self.NumscipiedEigenvalueComplexesArray=np.linalg.eigvals( self.NumscipiedValueFloatsArray ) #project self.NumscipiedRealEigenvalueFloatsArray=np.real( self.NumscipiedEigenvalueComplexesArray ) self.NumscipiedImagEigenvalueFloatsArray=np.imag( self.NumscipiedEigenvalueComplexesArray ) #debug ''' self.debug( [ 'We have computed the eigenvalues', ('self.',self,[ 'NumscipiedEigenvalueComplexesArray' ]) ] ) ''' #/#################/# # Compute Global # #Check if self.NumscipyingGlobalBool: #debug ''' self.debug( [ 'We compute some global properties' ] ) ''' #/###############/# # Compute basic statistics # #mean self.NumscipiedMeanGlobalFloatsArray=self.NumscipiedValueFloatsArray.mean( axis=0 ) #std self.NumscipiedStdGlobalFloatsArray=self.NumscipiedValueFloatsArray.std( axis=0 ) #/###############/# # Compute fourier amp and phase # #import from scipy.fftpack import fft #set self.NumscipiedSampleStepFloat=self.NumscipyingSampleFloatsArray[ 1 ]-self.NumscipyingSampleFloatsArray[ 0 ] #linspace self.NumscipiedFourierFrequencyFloatsArray=np.linspace( 0.0, 1.0/(2.0*self.NumscipiedSampleStepFloat), self.NumscipyingColsInt/2 ) #fft self.NumscipiedFourierGlobalComplexesArray=fft( self.NumscipiedMeanGlobalFloatsArray ) #amplitude self.NumscipiedFourierAmplitudeGlobalFloatsArray=( 2.0/self.NumscipyingColsInt )* np.abs( self.NumscipiedFourierGlobalComplexesArray[ 0:self.NumscipyingColsInt/2 ] ) #fourier self.NumscipiedFourierComplexesArray=np.array( map( lambda __NumscipiedValueFloatsArray: fft( __NumscipiedValueFloatsArray ), self.NumscipiedValueFloatsArray ) ) #get NumscipiedHalfFourierComplexesArray=self.NumscipiedFourierComplexesArray[ :, 0:self.NumscipyingColsInt/2 ] #ampitude self.NumscipiedFourierAmplitudeFloatsArray=( 2.0/float(self.NumscipyingColsInt) )* np.abs( NumscipiedHalfFourierComplexesArray ) #phase self.NumscipiedFourierPhaseFloatsArray=np.array( map( lambda __NumscipiedHalfFourierComplexesArray: getArgumentVariable( __NumscipiedHalfFourierComplexesArray ), NumscipiedHalfFourierComplexesArray ) ) #setCrossPhase self.setCrossPhase() #setExtremum self.setExtremum() #debug ''' self.debug( [ ('self.',self,[ 'NumscipiedFourierMaxCrossPhaseFloatsArray' ]) ] ) ''' # ( # xrange(self.NumscipyingColsInt), # [0]* # ) """ NumscipiedFourierCrossPhaseDict=map( lambda __NumscipiedFourierCrossPhaseTuple: ( __NumscipiedFourierCrossPhaseTuple[0][0], __NumscipiedFourierCrossPhaseTuple[1] ), self.NumscipiedFourierCrossPhaseTuplesList ) """ """ self.NumscipiedFourierMaxCrossPhaseFloatsArray=np.array( map( lambda __NumscipiedFourierMaxAmplitudeIndexIntsArray,__IndexInt: self.NumscipiedFourierCrossPhaseTuplesList[ __IndexInt, : ], self.NumscipiedFourierMaxAmplitudeIndexIntsArray, xrange(len(self.NumscipiedFourierMaxAmplitudeIndexIntsArray)) ) ) """ #/###############/# # Compute correlations # #import from scipy import signal #acf self.NumscipiedAutocorrelationGlobalFloatsArray=signal.correlate( self.NumscipiedMeanGlobalFloatsArray, self.NumscipiedMeanGlobalFloatsArray, mode="same" ) #cut #self.NumscipiedAutocorrelationGlobalFloatsArray=self.NumscipiedAutocorrelationGlobalFloatsArray[ # self.NumscipiedAutocorrelationGlobalFloatsArray.size/2: #] #debug ''' self.debug( [ 'We computed the correlations', ('self.',self,[ 'NumscipiedAutocorrelationGlobalFloatsArray' ]) ] ) ''' #/###############/# # Compute local maxima # """ #Maxima self.NumscipiedMaxGlobalIndexIntsArray=SYS.argmax( self.NumscipiedMeanGlobalFloatsArray ) #debug self.debug( [ 'We found the local extrema', ('self.',self,[ 'NumscipiedMaxGlobalIndexIntsArray' ]) ] ) #map NumscipiedMaxIndexIntsArray=map( lambda __SimulatedFloatsArray: SYS.argmax(__SimulatedFloatsArray), SimulatedFloatsArray ) """ #/#################/# # Reset to None # #set self.NumscipiedDiscreteStatRigidFunction=None self.NumscipiedContinuousStatRigidFunction=None
def setStabilizedTotalPerturbationComplexesArray(self): #/###############/# # Prepare the complex pulsation perturbation # init StabilizedTotalPerturbationComplexesArray #alias PerturbationComplex = self.StabilizedPerturbationComplex #copy self.StabilizedTotalPerturbationComplexesArray =- np.array( self.StabilizedPerturbationWeightFloatsArray[:], dtype=complex ) #/###############/# # Synaptic coupling # #exp #self.StabilizedSynapticPerturbationVariable=self.getSynapticPerturbationVariable( # PerturbationComplex # ) #debug #self.debug( # [ # ('self.',self,[ # 'StabilizedSynapticPerturbationVariable', # 'getSynapticPerturbationVariable', # 'StabilizedSynapticPerturbationMethodVariable' # ]) # ] #) #Check if self.StabilizedSynapticPerturbationMethodVariable!=None: #set self.StabilizedSynapticPerturbationComplexesArray=self.StabilizedSynapticPerturbationMethodVariable( PerturbationComplex ) #debug ''' self.debug( [ "Just before the synaptic set", ('self.',self,[ 'StabilizedPerturbationComplex', 'StabilizedTotalPerturbationComplexesArray', 'StabilizedSynapticPerturbationMethodVariable' ]) ] ) ''' #mul SYS.setMatrixArray( self.StabilizedTotalPerturbationComplexesArray, self.StabilizedSynapticPerturbationComplexesArray, np.ndarray.__mul__ ) #debug ''' self.debug( [ "Just after the synaptic set", ('self.',self,[ 'StabilizedPerturbationComplex', 'StabilizedTotalPerturbationComplexesArray', 'StabilizedSynapticPerturbationComplexesArray' ]) ] ) ''' #debug ''' self.debug( [ 'Ok we have mul the synaptic coupling', ('self.',self,[ 'StabilizedTotalPerturbationComplexesArray' ]) ] ) ''' #/###############/# # Neural response coupling # #exp self.StabilizedNeuralPerturbationComplexesArray=self.StabilizedNeuralPerturbationMethodVariable( PerturbationComplex ) #debug ''' self.debug( [ "PerturbationComplex is "+str(PerturbationComplex), ('self.',self,[ 'StabilizedNeuralPerturbationComplexesArray', 'StabilizedNeuralPerturbationMethodVariable' ]) ] ) ''' #mul SYS.setMatrixArray( self.StabilizedTotalPerturbationComplexesArray, self.StabilizedNeuralPerturbationComplexesArray, np.ndarray.__mul__ ) #debug ''' self.debug( [ 'Ok we have mul the neural coupling', ('self.',self,[ 'StabilizedTotalPerturbationComplexesArray', 'StabilizedNeuralPerturbationComplexesArray' ]) ] ) ''' #/###############/# # fill diagonal with also the leak identity term # #fill ''' np.fill_diagonal( self.StabilizedTotalPerturbationComplexesArray, self.getLeakNeuralPerturbationComplex( PerturbationComplex )+np.diag( self.StabilizedTotalPerturbationComplexesArray ) ) ''' #fill np.fill_diagonal( self.StabilizedTotalPerturbationComplexesArray, 1.+np.diag( self.StabilizedTotalPerturbationComplexesArray ) ) #debug '''
def stabilizeNetwork(self): #/###################/# # Determine the time constant structures # #set if type(self.StabilizingConstantTimeVariable)==None.__class__: self.StabilizingConstantTimeVariable=map( lambda __DeriveStabilizer: __DeriveStabilizer.LifingConstantTimeFloat, self.TeamDict['Populations'].ManagementDict.values() ) #debug ''' self.debug( [ ('self.',self,[ 'StabilizingConstantTimeVariable' ]) ] ) ''' #map map( lambda __TimeStr: SYS.setInitArray( self, 'Stabilize', __TimeStr+'Time' ), [ 'Constant', 'Delay', 'Decay', 'Rise' ] ) #/###################/# # Build the always fixed terms of the perturbation matrix # #debug ''' self.debug( [ 'We init the computations the StabilizedPerturbationWeightFloatsArray', ('self.',self,[ 'StationarizingConstantTimeVariable', 'StationarizedMeanWeightFloatsArray', 'StabilizedConstantTimeVariable' ]) ] ) ''' #set self.StabilizedPerturbationWeightFloatsArray=self.StationarizedMeanWeightFloatsArray[ : ] #mul SYS.setMatrixArray( self.StabilizedPerturbationWeightFloatsArray, self.StabilizedConstantTimeVariable, np.ndarray.__mul__ ) #debug ''' self.debug( [ 'In the end', ('self.',self,[ 'StabilizedPerturbationWeightFloatsArray' ]) ] ) ''' #/###################/# # Determine which function to get for the synaptic computation # #debug ''' self.debug( [ "We determine the type of Synaptic function", ('self.',self,[ 'StabilizedRiseTimeVariable', 'StabilizedDecayTimeVariable', 'StabilizedDelayTimeVariable' ]) ] ) ''' #Check if SYS.getIsNullBool( self.StabilizedRiseTimeVariable ): #Check if SYS.getIsNullBool( self.StabilizedDecayTimeVariable ): #Check if SYS.getIsNullBool( self.StabilizedDelayTimeVariable ): #set self.StabilizedSynapticPerturbationMethodVariable=lambda __PerturbationComplex:1. else: #set self.StabilizedSynapticPerturbationMethodVariable=self.getSynapticDelayPerturbationVariable else: #set self.StabilizedSynapticPerturbationMethodVariable=self.getSynapticDecayPerturbationVariable else: #set self.StabilizedSynapticPerturbationMethodVariable=self.getSynapticRisePerturbationVariable #/###################/# # Prepare the combinations to consider # #import import itertools #list self.StabilizedIndexIntsTuplesList=list( itertools.product( xrange(self.StationarizingUnitsInt), xrange(self.StationarizingUnitsInt) ) ) #debug ''' self.debug( [ 'We set a one root get', ('self.',self,[ 'StabilizedIndexIntsTuplesList' ]) ] ) self.getGlobalPerturbationRootFloatsTuple( (0.1,2.*np.pi*1.) ) ''' #import from numpy import linalg #set self.StabilizedDeterminantFunctionVariable=linalg.det #/################/# # Look for a rate instability # #debug ''' self.debug( [ "Ok first we look for a rate instability" ] ) ''' #set self.StabilizedLifersVariable = self.TeamDict['Populations'].ManagementDict.values() #map self.StabilizedMeanPerturbationNullFloatsList=map( lambda __DeriveStabilizer: __DeriveStabilizer.lif( _ComputeStationaryBool=False, _PerturbationLambdaVariable=0., _PerturbationMethodStr='Brunel', _ComputeNoisePerturbationBool=False ).LifedPerturbationMeanComplexVariable, self.StabilizedLifersVariable ) if self.StationarizingInteractionStr=="Spike" else [1.]*self.StationarizingUnitsInt #debug ''' self.debug( [ ('self.',self,[ 'StabilizedMeanPerturbationNullFloatsList' ]) ] ) ''' #set self.StabilizedNeuralPerturbationComplexesArrayesArray=np.zeros( self.StationarizingUnitsInt, dtype=complex ) #Check if self.StabilizingComputeBool: #get self.StabilizedNeuralPerturbationMethodVariable=getattr( self, 'getNeuralNullPerturbationVariable' ) #get StabilizedRateDetermintantFloatsTuple=self.getGlobalPerturbationRootFloatsTuple( (0.,0.) ) #get self.StabilizedIsStableBool=StabilizedRateDetermintantFloatsTuple[0]>0. self.StabilizedRateInstabilityBool=not self.StabilizedIsStableBool #debug ''' self.debug( [ 'Is it rate instable ?', "StabilizedRateDetermintantFloatsTuple is "+str(StabilizedRateDetermintantFloatsTuple), ('self.',self,[ 'StabilizedTotalPerturbationComplexesArray', 'StabilizedIsStableBool' ]) ] ) ''' #/################/# # Look for a hopf instability # #Check if self.StabilizedIsStableBool: #import import scipy.optimize #get self.StabilizedNeuralPerturbationMethodVariable=getattr( self, 'get'+self.StationarizingInteractionStr+'NeuralPerturbationVariable' ) #debug ''' self.debug( [ "There is no rate instability so we do a Hopf scan analysis", ('self.',self,['StabilizingScanFrequencyVariable']) ] ) ''' #type StabilizedScanType=type(self.StabilizingScanFrequencyVariable) #Check if StabilizedScanType==None.__class__: #Check StabilizedFirstList=list(np.logspace(0,3,10)) StabilizedSecondList=StabilizedFirstList[:] StabilizedSecondList.reverse() StabilizedSecondList=map(lambda __Variable:-__Variable,StabilizedSecondList) #set self.StabilizedStabilityScanFrequencyFloatsArray=np.array( StabilizedSecondList+StabilizedFirstList ) elif StabilizedScanType in [np.float64,float]: #Check self.StabilizedStabilityScanFrequencyFloatsArray=np.array( [self.StabilizingScanFrequencyVariable] ) else: #Check self.StabilizedStabilityScanFrequencyFloatsArray=np.array( self.StabilizingScanFrequencyVariable ) #debug ''' self.debug( [ ('self.',self,['StabilizedStabilityScanFrequencyFloatsArray']) ] ) ''' #check ''' if len(self.StabilizedStabilityScanFrequencyFloatsArray)==1: #debug self.debug( [ "We just debug here" ] ) #try just the first self.getGlobalPerturbationRootFloatsTuple( (-0.1,2.*np.pi*self.StabilizedStabilityScanFrequencyFloatsArray[0]) ) ''' #debug ''' self.debug( [ "Ok now we gradient" ] ) ''' #loop for __ScanFrequencyFloat in self.StabilizedStabilityScanFrequencyFloatsArray: #for __ScanFrequencyFloat in [100.]: #debug ''' self.debug( [ 'We try to find an instability around '+str(__ScanFrequencyFloat)+'Hz' ] ) ''' #Get the solve of the ScipyOptimizeRoot StabilizedOptimizeRoot=scipy.optimize.root( self.getGlobalPerturbationRootFloatsTuple, (-0.1,2.*np.pi*__ScanFrequencyFloat), #method='lm', #tol=0.001 options={ #'maxiter':1000, #'ftol':0.001, #'direc':np.array([-0.1,0.1]) }, ) #set StabilizedErrorFloat=np.sum(StabilizedOptimizeRoot.fun**2) #debug ''' self.debug( [ 'StabilizedOptimizeRoot is ', str(StabilizedOptimizeRoot), "StabilizedErrorFloat is ", str(StabilizedErrorFloat) ] ) ''' #set self.StabilizedOptimizeRoot=StabilizedOptimizeRoot #Check if StabilizedOptimizeRoot.success and StabilizedErrorFloat<0.001: #debug ''' self.debug( [ "It is a success", ('self.',self,[ 'StabilizedBiggestLambdaFloatsTuple', ]), "StabilizedOptimizeRoot.x is "+str(StabilizedOptimizeRoot.x) ] ) ''' #Check if StabilizedOptimizeRoot.x[0]>0.: #set self.StabilizedIsStableBool=False #set self.StabilizedInstabilityStr="Hopf" #set self.StabilizedInstabilityLambdaFloatsTuple=tuple( StabilizedOptimizeRoot.x ) self.StabilizedBiggestLambdaFloatsTuple=self.StabilizedInstabilityLambdaFloatsTuple #set self.StabilizedInstabilityFrequencyFloat=self.StabilizedInstabilityLambdaFloatsTuple[1]/( 2.*np.pi ) #break break elif len( self.StabilizedBiggestLambdaFloatsTuple )==0 or StabilizedOptimizeRoot.x[0]>self.StabilizedBiggestLambdaFloatsTuple[0]: #Check self.StabilizedBiggestLambdaFloatsTuple=tuple( StabilizedOptimizeRoot.x )