notebook.community

Edit and run

Un solo parametro





In [20]:



    


import numpy
import tensorflow as tf
from matplotlib import pyplot
import time

maxFreq = 120
minFreq = 80

tFft = 8192
stepFreq = 1/tFft
nFreqs = numpy.int((maxFreq-minFreq)/stepFreq)
frequenze = tf.range(minFreq,maxFreq, delta = stepFreq)

sessione = tf.Session()

def preparDati(N):
    valori = tf.random_normal([N], dtype=tf.float32)
    ampiezza = tf.pow(tf.abs(valori),2)+0.1
    return ampiezza

def crosscorrela(funz1,funz2, N):
    media1 = tf.reduce_mean(funz1)
    media2 = tf.reduce_mean(funz2)
    
    funz1=  funz1-media1
    funz2 = funz2-media2
    
    sigma1 = tf.sqrt(tf.reduce_sum(funz1*funz1)/N)
    sigma2 = tf.sqrt(tf.reduce_sum(funz2*funz2)/N)

    prodotto = funz1*funz2
    crosscorr = (tf.reduce_sum(prodotto)/N)/(sigma1*sigma2)
    return crosscorr
    
def matchedfiltra(funz,filtro, N):
    media = tf.reduce_mean(funz)
    funz= funz-media
    filtro = filtro-media
    sigma = tf.sqrt(tf.reduce_sum(funz*funz)/N)
    
    prodotto = filtro*funz/tf.pow(sigma,2)
    normalizzatore = tf.reduce_sum(tf.pow(filtro/sigma,2))
    filtraggio = tf.reduce_sum(prodotto)/normalizzatore
    return filtraggio

def segnala(freq, N ,esp,cut):
	#alpha = tf.range(-esp,esp, delta = 0.01)
	
	#nAlphas = tf.size(alpha)
	#alpha = tf.reshape(alpha, shape=[nAlphas,1] )

	#espansoreFreq = tf.ones([nAlphas,1])
	#espansoreAlpha = tf.ones([1,N])

	#freqExp = tf.multiply(frequenze,espansoreFreq)
	#alphExp = tf.multiply(espansoreAlpha,alpha)
	
	#segnale = tf.pow(freqExp/cut, alphExp)
	segnale = tf.pow(freq/cut, esp)
	
	return segnale

amplificaSegnale = 0.01
spettroSegnale = segnala(frequenze,nFreqs, 3,maxFreq)
spettroSegnale = spettroSegnale*amplificaSegnale

#definisco dati
esempioTemplate = spettroSegnale#spettroSegnale[-1]
noise = preparDati(nFreqs)
noise2 = preparDati(nFreqs)
noiseIniettato = noise+esempioTemplate
noise2Iniettato = noise2+esempioTemplate

spettroHan = numpy.load('/home/protoss/Documenti/Gravit_sper/dati/spettroHanMediato.npy')
spettroLiv = numpy.load('/home/protoss/Documenti/Gravit_sper/dati/spettroLivMediato.npy')

han = tf.constant(spettroHan)
liv = tf.constant(spettroLiv)

hanIniettato = tf.constant(spettroHan)+spettroSegnale
livIniettato = tf.constant(spettroLiv)+spettroSegnale
    

#faccio matched filters
filtri = numpy.zeros(6)

filtri[0] = sessione.run(matchedfiltra(noise,esempioTemplate,nFreqs))
filtri[1] = sessione.run(matchedfiltra(noiseIniettato,esempioTemplate,nFreqs))

filtri[2] = sessione.run(matchedfiltra(han, esempioTemplate,nFreqs))
filtri[3] = sessione.run(matchedfiltra(liv, esempioTemplate,nFreqs))

filtri[4] = sessione.run(matchedfiltra(hanIniettato, esempioTemplate,nFreqs))
filtri[5] = sessione.run(matchedfiltra(livIniettato, esempioTemplate,nFreqs))



print(filtri)

corrs = numpy.zeros(4)
corrs[0] = sessione.run(crosscorrela(noise,noise2,nFreqs))
corrs[1] = sessione.run(crosscorrela(noiseIniettato,noise2Iniettato,nFreqs))
corrs[2] = sessione.run(crosscorrela(han,liv,nFreqs))
corrs[3] = sessione.run(crosscorrela(hanIniettato,livIniettato,nFreqs))

print(corrs)


#freqNP = numpy.arange(80,120, 1/8192)

#%matplotlib notebook
#pyplot.loglog()
#a = pyplot.scatter(freqNP,spettroHan, s = 5)
#a = pyplot.scatter(freqNP,spettroLiv, s = 5)
##pyplot.show()



    


















    






[  1.49340003e-05  -3.13638975e-06  -2.37416207e-05  -1.19184961e-05
  -5.45924081e-07   2.30925707e-05]
[ 0.00307303 -0.00312906  0.08548458  0.08527081]

n valori 1 parametro





In [7]:



    


import numpy
import tensorflow as tf
from matplotlib import pyplot
import time

maxFreq = 120
minFreq = 80

tFft = 8192
stepFreq = 1/tFft
nFreqs = numpy.int((maxFreq-minFreq)/stepFreq)
frequenze = tf.range(minFreq,maxFreq, delta = stepFreq)

sessione = tf.Session()

def preparDati(N):
    valori = tf.random_normal([N], dtype=tf.float32)
    ampiezza = tf.pow(tf.abs(valori),2)+0.1
    return ampiezza


def mediasigma(dati,iniezione,N):
    funz = dati+iniezione
    media = tf.reduce_mean(funz)
    funzrid = funz - media
    sigma = tf.sqrt(tf.reduce_sum(funzrid*funzrid)/N)
    return media, sigma

def iniettatore(dati,iniezione):
    nosegnale = tf.zeros(shape=(60,nFreqs))
    segnale = nosegnale+iniezione
    funzIniet = dati + segnale
    return funzIniet


def matchedfiltra(funz,iniezione,filtro, N):
    media, sigma = mediasigma(funz,iniezione,N)
    
    funz = iniettatore(funz, iniezione)
    
    funz= funz-media
    filtro = filtro-media
        
    prodotto = (filtro*funz)/tf.pow(sigma,2)
    normalizzatore = tf.reduce_sum(tf.pow((filtro)/sigma,2),1)
    filtraggio = tf.reduce_sum(prodotto,1)/normalizzatore
    filtraggio = filtraggio#/sigma
    return filtraggio

def segnala(freq, N ,esp,cut):
	alpha = tf.range(-esp,esp, delta = 0.1)
	
	nAlphas = tf.size(alpha)
	alpha = tf.reshape(alpha, shape=[nAlphas,1] )

	espansoreFreq = tf.ones([nAlphas,1])
	espansoreAlpha = tf.ones([1,N])

	freqExp = tf.multiply(frequenze,espansoreFreq)
	alphExp = tf.multiply(espansoreAlpha,alpha)
	
	segnale = tf.pow(freqExp/cut, alphExp)
	return segnale, nAlphas



    











In [25]:



    


amplificaSegnale = 10
spettroSegnale, nEsps = segnala(frequenze,nFreqs, 3,maxFreq)
print(sessione.run(nEsps), sessione.run(spettroSegnale).size)
spettroSegnale = spettroSegnale*amplificaSegnale



noise = preparDati(nFreqs)


spettroHan = numpy.load('/home/protoss/Documenti/Gravit_sper/dati/spettroHanMediato.npy')
spettroLiv = numpy.load('/home/protoss/Documenti/Gravit_sper/dati/spettroLivMediato.npy')


han = tf.constant(spettroHan)
liv = tf.constant(spettroLiv)

segnaleScelto = spettroSegnale[59]
nosegnale = tf.zeros(nFreqs)

filtroHanIn = sessione.run(matchedfiltra(han,segnaleScelto,spettroSegnale,nFreqs))
filtroHan = sessione.run(matchedfiltra(han,nosegnale,spettroSegnale,nFreqs))

filtroLivIn = sessione.run(matchedfiltra(liv,segnaleScelto,spettroSegnale,nFreqs))
filtroLiv = sessione.run(matchedfiltra(liv,nosegnale,spettroSegnale,nFreqs))

filtroRanIn = sessione.run(matchedfiltra(noise,segnaleScelto,spettroSegnale,nFreqs))
filtroRan = sessione.run(matchedfiltra(noise,nosegnale,spettroSegnale,nFreqs))

#freqNP = numpy.arange(80,120, 1/8192)

#%matplotlib notebook
#pyplot.loglog()
#a = pyplot.scatter(freqNP,spettroHan, s = 5)
#a = pyplot.scatter(freqNP,spettroLiv, s = 5)
##pyplot.show()



    


















    






60 19660800

















In [43]:



    


%matplotlib qt
#pyplot.loglog()
#a = pyplot.scatter(numpy.arange(-3,3,0.1),filtroHanIn, s = 5, label = 'H + inj')
#b = pyplot.scatter(numpy.arange(-3,3,0.1),filtroLivIn, s = 5, label = 'L + inj')
#c = pyplot.scatter(numpy.arange(-3,3,0.1),filtroRanIn, s = 5, label = 'Random + inj')
d = pyplot.scatter(numpy.arange(-3,3,0.1),filtroHan, s = 5,label = 'H')
#e = pyplot.scatter(numpy.arange(-3,3,0.1),filtroLiv, s = 5,label = 'L')
#f = pyplot.scatter(numpy.arange(-3,3,0.1),filtroRan, s = 5,label = 'Random')
pyplot.legend()
pyplot.title('Weak injection')
pyplot.ylabel('filter estimator')
#pyplot.xlabel(' $\alpha$ ')
pyplot.tight_layout()
#pyplot.show()



    











In [1]:



    


import numpy

test velocità





In [20]:



    


import numpy
import tensorflow as tf
from matplotlib import pyplot
import time

num = 10
parametriBench = numpy.zeros((num,4))
for i in numpy.arange(1,num):
    maxFreq = 120
    minFreq = 80

    tFft = 8192
    stepFreq = 1/tFft
    nFreqs = numpy.int((maxFreq-minFreq)/stepFreq)
    frequenze = tf.range(minFreq,maxFreq, delta = stepFreq)

    sessione = tf.Session()

    def preparDati(N):
        valori = tf.random_normal([N], dtype=tf.float32)
        ampiezza = tf.pow(tf.abs(valori),2)+0.1
        return ampiezza


    def mediasigma(dati,iniezione,N):
        funz = dati+iniezione
        media = tf.reduce_mean(funz)
        funzrid = funz - media
        sigma = tf.sqrt(tf.reduce_sum(funzrid*funzrid)/N)
        return media, sigma

    def iniettatore(dati,iniezione):
        nosegnale = tf.zeros(shape=(nSteps,nFreqs))
        segnale = nosegnale+iniezione
        funzIniet = dati + segnale
        return funzIniet


    def matchedfiltra(funz,iniezione,filtro, N):
        media, sigma = mediasigma(funz,iniezione,N)

        funz = iniettatore(funz, iniezione)

        funz= funz-media
        filtro = filtro-media
        
        prodotto = (filtro*funz)/tf.pow(sigma,2)
        normalizzatore = tf.reduce_sum(tf.pow((filtro)/sigma,2),1)
        filtraggio = tf.reduce_sum(prodotto,1)/normalizzatore
        filtraggio = filtraggio#/sigma
        return filtraggio

    def segnala(freq, N, nEsp, cut):
        esp = 10
        step = numpy.float32(esp/nEsp)
        
        alpha = tf.range(0,esp, delta = step)

        nAlphas = tf.size(alpha)
        alpha = tf.reshape(alpha, shape=[nAlphas,1] )

        espansoreFreq = tf.ones([nAlphas,1])
        
        espansoreAlpha = tf.ones([1,N])
        freqExp = tf.multiply(frequenze,espansoreFreq)
        alphExp = tf.multiply(espansoreAlpha,alpha)

        segnale = tf.pow(freqExp/cut, alphExp)
        return segnale

    nSteps = i
    spettroSegnale= segnala(frequenze,nFreqs, nSteps,maxFreq)

    spettroHan = numpy.load('/home/protoss/Documenti/Gravit_sper/dati/spettroHanMediato.npy')


    han = tf.constant(spettroHan)

    #segnaleScelto = spettroSegnale[59]
    nosegnale = tf.zeros(nFreqs)

    start = time.time()
    filtroHan = sessione.run(matchedfiltra(han,nosegnale,spettroSegnale,nFreqs))
    stop = time.time()
    
    tempo = stop-start
    
    parametriBench[i,0] = tempo
    parametriBench[i,1] = nFreqs
    parametriBench[i,2] = nSteps
    parametriBench[i,3] = nFreqs*nSteps
    print(i)
    tf.reset_default_graph()
    sessione.close()

numpy.save('bench.npy', parametriBench)



    


















    






1
2
3
4
5
6
7
8
9

















In [2]:



    


import numpy
benches = numpy.load('/home/protoss/Documenti/Gravit_sper/dati/bench.npy')
benchesNP = numpy.load('bench.npy')



    











In [6]:



    


from matplotlib import pyplot
%matplotlib qt
#pyplot.loglog()

d = pyplot.scatter(benches[2:,2],benches[2:,0], s = 5,label = 'Tensorflow - Tesla k20')
e = pyplot.scatter(benchesNP[2:,2]+2,benchesNP[2:,0], s = 5,label = 'Numpy - Intel i7')
pyplot.legend()
pyplot.title('Computing time')
pyplot.ylabel('Time (s)')
pyplot.xlabel('Number of parameters')
pyplot.tight_layout()
#pyplot.show()



    











In [10]:



    


print(benchesNP[:,0])



    


















    






[ 0.          0.          0.          0.          0.          0.          0.
  0.          0.          0.          0.11253834  0.12937355  0.13829756
  0.14275885  0.15353966  0.16506243  0.17430305  0.187567    0.20076776
  0.21246243  0.22126722  0.23141432  0.24351239  0.25796843]

















In [1]:



    


import numpy
import time

num =24
parametriBench = numpy.zeros((num,4))
for i in numpy.arange(2,num):
    maxFreq = 120
    minFreq = 80

    tFft = 8192
    stepFreq = 1/tFft
    nFreqs = numpy.int((maxFreq-minFreq)/stepFreq)
    frequenze = numpy.arange(minFreq,maxFreq, stepFreq)


    def mediasigma(dati,iniezione,N):
        funz = dati+iniezione
        media = numpy.average(funz)
        funzrid = funz - media
        sigma = numpy.sqrt(numpy.sum(funzrid*funzrid)/N)
        return media, sigma

    def iniettatore(dati,iniezione):
        nosegnale = numpy.zeros((nSteps,nFreqs))
        segnale = nosegnale+iniezione
        funzIniet = segnale+dati
        return funzIniet


    def matchedfiltra(funz,iniezione,filtro, N):
        media, sigma = mediasigma(funz,iniezione,N)

        funz = iniettatore(funz, iniezione)

        funz= funz-media

        filtro = filtro-media 
        filtro = numpy.transpose(filtro)
        #print(filtro.shape, funz.shape)
        prodotto = (filtro*funz)/numpy.power(sigma,2)
        
     
        
        normalizzatore = numpy.sum(numpy.power((filtro)/sigma,2),1)
        filtraggio = numpy.sum(prodotto,1)/normalizzatore
        filtraggio = filtraggio#/sigma
        return filtraggio

    def segnala(freq, N, nEsp, cut):
        esp = 0.5
        step = numpy.float32(esp/nEsp)
        
        alpha = numpy.arange(0,esp, step)

        nAlphas = alpha.size
        

        espansoreFreq = numpy.ones(nAlphas)
        espansoreAlpha = numpy.ones(N)
        
        
        freqExp = numpy.outer(frequenze,espansoreFreq)
        alphExp = numpy.outer(espansoreAlpha,alpha)

        segnale = numpy.power(freqExp/cut, alphExp)
        return segnale

    nSteps = i
    spettroSegnale= segnala(frequenze,nFreqs, nSteps,maxFreq)

    spettroHan = numpy.load('/home/protoss/Documenti/Gravit_sper/dati/spettroHanMediato.npy')


    han = spettroHan

    #segnaleScelto = spettroSegnale[59]
    nosegnale = numpy.zeros(nFreqs)

    start = time.time()
    filtroHan = matchedfiltra(han,nosegnale,spettroSegnale,nFreqs)
    stop = time.time()
    
    tempo = stop-start
    #print(tempo)
    parametriBench[i,0] = tempo
    parametriBench[i,1] = nFreqs
    parametriBench[i,2] = nSteps
    parametriBench[i,3] = nFreqs*nSteps
    #print(i)


numpy.save('bench.npy', parametriBench)



    











In [2]:



    






    











In [ ]:

Content source: iurilarosa/Gravisper

Similar notebooks:

notebook.community | gallery | about