Upload files to ''

relvaneOfPulses.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Aug 17 21:52:28 2020
+
+@author: p277634
+"""
+
+import numpy as np
+import sys
+import visArchis_seq as v
+# import optimProbs as oudp
+import myKAOctrl_stageSeq as udp
+import scipy as sp
+import copy
+
+nSample = 1000
+topNbest = 10000 #~the best 1%
+
+d = v.LoadData()
+
+
+d.nameModel = 'stgSequence_Lopt_allPu1500_wE_P030_optIni_v5_fixG0p15L0p6_Stg'
+
+
+d.nameEnding =''
+d.stages = [1,2,3,4] # te read file names
+# saveTo = '/Users/p277634/kaoAsoMemSimu/analysis/relevanceOfPulses_P040_G0p3L0p7.npz'
+saveTo = './dataSave/relevanceOfPulses_P030_G0p15L0p6.npz'
+
+
+# get data
+pulse   = d.getPulses()
+fit     = d.getFitness()
+m       = d.getBestModel()
+# pli     = d.getPLI()
+# Merge all islands
+allPulse, allCost, allsCor, allRenv, allFC = [None]*pulse.nStg, [None]*pulse.nStg, [None]*pulse.nStg, [None]*pulse.nStg, [None]*pulse.nStg
+for sIx in range(pulse.nStg):
+    mergeP_, mergeC_, mergeScor_, mergeRenv_ = [], [], [], [] 
+    # mergeFC_ = []
+    for iIx in range(pulse.nIsla):
+        mergeP_.append(pulse.d[iIx][sIx])
+        mergeC_.append(fit.cost[iIx][sIx])
+        mergeScor_.append(fit.sCor[iIx][sIx].ravel())
+        mergeRenv_.append(np.squeeze(fit.renv[iIx][sIx]))
+        # mergeFC_.append(pli[iIx][sIx])
+    allPulse[sIx] = np.vstack(mergeP_)
+    allCost[sIx] = np.hstack(mergeC_)
+    allsCor[sIx] = np.hstack(mergeScor_)
+    allRenv[sIx] = np.vstack(mergeRenv_)
+    # allFC[sIx] = np.squeeze(np.vstack(mergeFC_))
+
+# Keep top N best solutions    
+pulseTh, costTh, fcTh, sCorTh, rEnvTh = [None]*4, [None]*4, [None]*4, [None]*4, [None]*4
+minCostTh = np.zeros(4)
+for i in range(4):
+    pulseTh[i]  = allPulse[i][ np.argsort(allCost[i])[-topNbest:], :]
+    costTh[i]   = allCost[i][  np.argsort(allCost[i])[-topNbest:]]
+    sCorTh[i]   = allsCor[i][  np.argsort(allCost[i])[-topNbest:]]
+    rEnvTh[i]   = allRenv[i][  np.argsort(allCost[i])[-topNbest:], :]
+    # fcTh[i]     = allFC[i][np.argsort(allCost[i])[-topNbest:],:]
+    minCostTh[i]= np.min(costTh[i])
+iXpick   = np.random.choice(np.arange(topNbest), size=nSample, replace=False)
+  
+del pulse, fit, allPulse, allCost, allRenv, allsCor
+
+# best sequence of pulses and scores
+pulseBest = np.zeros((m.nroi,m.nStg))
+fitBest   = np.zeros(m.nStg)
+sCorBest  = np.zeros(m.nStg)
+rEnvBest  = np.zeros((m.nStg,68))
+for i in range(m.nStg):
+    pulseBest[:,i]  = m.logs[i][0][0]
+    fitBest[i]      = m.logs[i][0][3]
+    sCorBest[i]     = m.logs[i][0][6] 
+    rEnvBest[i,:]   = np.squeeze(m.logs[i][0][9])
+
+fitRef  = np.zeros((nSample,4))
+sCorRef = np.zeros((nSample,4))
+rEnvRef = np.zeros((nSample,4,68))
+pliRef  = np.zeros((nSample,2278,4))
+# pliTe   = np.zeros((nSample,68,2278,4))
+fitTe   = np.zeros((nSample,68,4))
+sCorTe  = np.zeros((nSample,68,4))
+rEnvTe  = np.zeros((nSample,68,4,68))
+pulseTe = np.zeros((nSample,68,4))
+
+for iXt in range(nSample):
+    for iXs in range(4):
+        pulseRand = pulseTh[iXs][iXpick[iXt],:] # pulse to be tested
+        pulseTe[iXt,:,iXs] = pulseRand
+        stages = list(range(iXs+1))
+        if len(stages) == 1:
+            kao = udp.KAOmodel(stageIx=stages[0])
+        else:
+            kao = udp.KAOmodel(stageIx=stages)
+        # reference model with all pulses
+        # kao = udp.KAOmodel(stageIx=stages)
+        kao._setHistDelayAndContainers()
+        kao._edgesImpulse()  
+        kao._getEmpiReativEnv()
+        kao.doNoise(variance=0)
+        # do pulses
+        pulseTest = copy.deepcopy(pulseBest[:,stages])
+        pulseTest[:,iXs] = pulseRand
+        kao.pulse = pulseTest
+        
+        kao.runModel_Pulsein_noise()
+        
+        fit_ = kao.similarityAllPLIs()
+        fitRef[iXt, iXs] = fit_[iXs]
+        pliRef[iXt, :, iXs] = kao.pli[iXs,:]
+        
+        kao.relativeEnvBuPre()
+        kao.getScorrelRelEnv()
+        sCorRef[iXt, iXs] = kao.sCor[iXs]   
+        rEnvRef[iXt, iXs,:] = kao.relEnv[:,iXs]  
+        # relevance of a missing pulse
+        for iXroi in range(68):
+            if len(stages) == 1:
+                kao = udp.KAOmodel(stageIx=stages[0])
+            else:
+                kao = udp.KAOmodel(stageIx=stages)            
+            kao._setHistDelayAndContainers()
+            kao._edgesImpulse()  
+            kao._getEmpiReativEnv()
+            kao.doNoise(variance=0)
+            # do pulses
+            pulseTest = copy.deepcopy(pulseBest[:,stages])
+            pulseTest[:,iXs] = pulseRand
+            pulseTest[iXroi,iXs] = 0
+            kao.pulse = pulseTest
+            
+            kao.runModel_Pulsein_noise()
+    
+            fit_ = kao.similarityAllPLIs()
+            fitTe[iXt, iXroi, iXs] = fit_[iXs]
+            
+            kao.relativeEnvBuPre()
+            kao.getScorrelRelEnv()
+            sCorTe[iXt, iXroi, iXs]   = kao.sCor[iXs]
+            rEnvTe[iXt, iXroi, iXs,:] = kao.relEnv[:,iXs]
+            
+np.savez(saveTo, rEnvTe=rEnvTe, sCorTe=sCorTe, fitTe=fitTe, pulseTe=pulseTe, pulseTh=pulseTh,costTh=costTh,iXpick=iXpick,
+         fitRef=fitRef, sCorRef=sCorRef, pliRef=pliRef, rEnvRef=rEnvRef, sCorTh=sCorTh, rEnvTh=rEnvTh,
+         pulseBest=pulseBest, fitBest=fitBest, sCorBest=sCorBest, rEnvBest=rEnvBest)

visArchis_seq.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu May 28 07:55:23 2020
+
+@author: p277634
+"""
+
+import numpy as np
+import matplotlib.pyplot as pl
+from itertools import combinations
+import scipy.io as sio
+import copy
+
+
+class BaseData():
+    def __init__(self,dataIni, stages):
+        self.nroi   = 68
+        self.d      = None
+        self.nStg   = len(stages)
+        # self.stgIx  = stages-1
+        self.sizePop    = np.load(dataIni, allow_pickle=True)['sizeP'].item()
+        self.pMig       = np.load(dataIni, allow_pickle=True)['pMig'].item()
+        self.nIsla      = np.load(dataIni, allow_pickle=True)['nIsla'].item()
+    
+
+class LoadData():
+    def __init__(self):
+        self.pathOptData    = './data/'
+        self.velocity       = 5
+        self.nameModel      = 'S1_StgSequence_allPu1000_wE_P030_optIni_v' + str(self.velocity)
+        self.nameEnding     = '_fixGL_Stg'
+        self.stages         = [0] # list with stages indexes
+        self.var2logIx      = {'pulse':[0],'order':[1,2],'fit':[3,5,6],'fc':[4],'env':[7,8,9]}
+        
+    def getBestModel(self):
+        dataIni        = self.pathOptData + self.nameModel + str(self.stages[0]) + self.nameEnding + '.npz'
+        m = BaseData(dataIni, self.stages)
+        dataread = self.pathOptData + self.nameModel  + self.nameEnding + 'trialZ.npz'
+        m.z       = np.load(dataread, allow_pickle=True)['sim_z']
+        m.logs    = np.load(dataread, allow_pickle=True)['sim_log']
+        print('files: ', np.load(dataread, allow_pickle=True).files)
+        # m.edgePulse = np.load(dataread, allow_pickle=True)['edgePulse']
+        return m
+          
+    def getPulses(self):
+        dataIni        = self.pathOptData + self.nameModel + str(self.stages[0])  + self.nameEnding + '.npz'
+        pulse = BaseData(dataIni, self.stages)
+        pulse.d, pulse.ener = [[None]*pulse.nStg ]*pulse.nIsla, [[None]*pulse.nStg ]*pulse.nIsla
+        for iXstg, stage in enumerate(self.stages):
+            dataread        = self.pathOptData + self.nameModel + str(stage)  + self.nameEnding + '.npz'
+            dataLog         = np.load(dataread, allow_pickle=True)['logsUDP']
+            for iXisla, isla in enumerate(dataLog):
+                pulse_ = np.array([log_[0] for log_ in isla])#.astype(np.float32)
+                # pulse.ener[iXisla][iXstg]   = np.sum(np.abs(pulse_), axis=1)                                  
+                pulse.d[iXisla][iXstg]      = pulse_
+        return pulse
+                
+    def getFitness(self):
+        dataIni        = self.pathOptData + self.nameModel + str(self.stages[0]) + self.nameEnding  + '.npz'
+        fit = BaseData(dataIni, self.stages)
+        fit.cost, fit.iXsort = [[None]*fit.nStg ]*fit.nIsla, [[None]*fit.nStg ]*fit.nIsla
+        fit.raw, fit.renv, fit.sCor = [[None]*fit.nStg ]*fit.nIsla, [[None]*fit.nStg ]*fit.nIsla, [[None]*fit.nStg ]*fit.nIsla
+        for iXstg, stage in enumerate(self.stages):
+            dataread        = self.pathOptData + self.nameModel + str(stage)  + self.nameEnding + '.npz'
+            dataLog         = np.load(dataread, allow_pickle=True)['logsUDP']
+            for iXisla, isla in enumerate(dataLog):
+                # fit.raw[iXisla][iXstg]   = np.array([log_[3] for log_ in isla]).astype(np.float32)
+                fitCost_ = np.array([log_[5] for log_ in isla])#.astype(np.float32) 
+                fit.cost[iXisla][iXstg]  = fitCost_
+                # fit.iXsort[iXisla][iXstg]= np.argsort(fitCost_)
+                fit.sCor[iXisla][iXstg]  = np.array([log_[6] for log_ in isla])
+                fit.renv[iXisla][iXstg]  = np.array([log_[9] for log_ in isla])
+        return fit
+    
+    def getPLI(self):
+        dataIni        = self.pathOptData + self.nameModel + str(self.stages[0])  + self.nameEnding + '.npz'
+        g = BaseData(dataIni, self.stages)
+        pli = [[None]*g.nStg ]*g.nIsla
+        for iXstg, stage in enumerate(self.stages):
+            dataread        = self.pathOptData + self.nameModel + str(stage)  + self.nameEnding + '.npz'
+            dataLog         = np.load(dataread, allow_pickle=True)['logsUDP']
+            for iXisla, isla in enumerate(dataLog):
+                # fit.raw[iXisla][iXstg]   = np.array([log_[3] for log_ in isla]).astype(np.float32)
+                pli[iXisla][iXstg]  = np.array([log_[4] for log_ in isla])   
+        return pli
+        
+    def getEnvelopes(self):
+        dataIni        = self.pathOptData + self.nameModel + str(self.stages[0])  + self.nameEnding  + '.npz'
+        env = BaseData(dataIni, self.stages)
+        env.mStg = [[None]*env.nStg ]*env.nIsla
+        env.mBu, env.relOn   = [[None]*env.nStg ]*env.nIsla, [[None]*env.nStg ]*env.nIsla
+        for iXstg, stage in enumerate(self.stages):
+            dataread        = self.pathOptData + self.nameModel + str(stage)  + self.nameEnding + '.npz'
+            dataLog         = np.load(dataread, allow_pickle=True)['logsUDP']
+            for iXisla, isla in enumerate(dataLog):
+                env.mStg[iXisla][iXstg]   = np.array([log_[7] for log_ in isla]).astype(np.float32)
+                env.mBu[iXisla][iXstg]    = np.array([log_[8] for log_ in isla]).astype(np.float32)
+                env.relOn[iXisla][iXstg]  = np.array([log_[9] for log_ in isla]).astype(np.float32)       
+        return env        
+        
+    def getOrders(self):
+        dataIni        = self.pathOptData + self.nameModel + str(self.stages[0])  + self.nameEnding + '.npz'
+        sync = BaseData(dataIni, self.stages)
+        sync.g, sync.l = [[None]*sync.nStg ]*sync.nIsla, [[None]*sync.nStg ]*sync.nIsla
+        sync.metaL, sync.metaG, sync.metaLm = [[None]*sync.nStg ]*sync.nIsla, [[None]*sync.nStg ]*sync.nIsla, [[None]*sync.nStg ]*sync.nIsla
+        for iXstg, stage in enumerate(self.stages):
+            dataread        = self.pathOptData + self.nameModel + str(stage)  + self.nameEnding + '.npz'
+            dataLog         = np.load(dataread, allow_pickle=True)['logsUDP']
+            for iXisla, isla in enumerate(dataLog):
+                ord_    = np.array([log_[1] for log_ in isla]).astype(np.float32)
+                sync.g[iXisla][iXstg]       = ord_[:,0]
+                sync.l[iXisla][iXstg]       = ord_[:,1]
+                sync.metaG[iXisla][iXstg]   = ord_[:,2] 
+                metaL_ = np.array([log_[2] for log_ in isla]).astype(np.float32)
+                sync.metaL[iXisla][iXstg]   = metaL_
+                sync.metaLm[iXisla][iXstg]  = np.mean(metaL_, axis=1)
+        return sync        
+                
+