def process(inp_r, inp_s):
num_samples = sr.get_num_samples(inp_s)
d_range = sr.get_ranges(inp_r) # ,num_samples,size)
f_sig = open(inp_s, 'r')
d_sig = np.fromfile(f_sig, dtype=int, sep=' ')
d_sig.shape = (d_sig.size / num_samples, num_samples)
d_sig = np.zeros_like(d_sig)
print d_sig.shape, d_sig.size
for r in d_range:
d_sig[r[0]][r[1]:r[2]] = 1
d_sig.tofile(open('ans_' + inp_s, 'w'), sep=' ', format="%d")
def process(inp_r, inp_s):
num_samples = sr.get_num_samples(inp_s)
d_range = sr.get_ranges(inp_r) # ,num_samples,size)
f_sig = open(inp_s,'r')
d_sig = np.fromfile(f_sig,dtype=int,sep=' ')
d_sig.shape = ( d_sig.size/num_samples,num_samples )
d_sig = np.zeros_like(d_sig)
print d_sig.shape, d_sig.size
for r in d_range:
d_sig[r[0]][r[1]:r[2]] = 1
d_sig.tofile(open('ans_'+inp_s,'w'),sep=' ',format="%d")
def __init__(self, run_num, plane, window):
no_noise = "%s_sig_no_noise_%s.csv" % (run_num, plane)
ranges = "sig_%s_sig_no_noise_%s.csv" % (run_num, plane)
time_noise = "%s_sig_time_noise_%s.csv" % (run_num, plane)
freq_noise = "%s_sig_freq_noise_%s.csv" % (run_num, plane)
win_fraction = 5
self.window = window
self.run_num = run_num
self.plane = plane
print "getting range info", ranges
self.num_samples = sr.get_num_samples(no_noise)
self.d_range = sr.get_ranges(ranges)
self.inp_sig = self.get_data(no_noise)
self.inp_noise_time = self.get_data(time_noise)
self.inp_noise_freq = self.get_data(freq_noise)
print "done with data reading"
self.d_only_nt = self.inp_noise_time - self.inp_sig
self.d_only_nf = self.inp_noise_freq - self.inp_sig
print "done with noise calc"
self.answers = np.zeros(self.inp_sig.size, dtype=np.bool_)
self.answers.shape = self.inp_sig.shape
for r in self.d_range:
self.answers[r[0]][r[1]:r[2]] = True
print "done with setting answers"
seq_X = []
seq_y = []
seq_n = []
ns = (self.d_only_nt, self.d_only_nf)
for r in self.d_range:
wire = r[0]
mid = r[5]
start = max(r[1] - (self.window / win_fraction), 0)
end = min(r[2] + self.window / win_fraction, self.num_samples)
if end - start < self.window:
# the window is too small, make it bigger
if start < self.window: end = start + self.window
else: start = end - self.window
rstart = np.random.randint(0,
high=self.num_samples - (end - start))
rend = rstart + (end - start)
noise_win = ns[np.random.randint(2)][wire][rstart:rend]
noise = ns[np.random.randint(2)][wire][start:end]
#nt = self.d_only_nt[wire][start:end]
#nf = self.d_only_nf[wire][start:end]
#ns = nt #+nf
#largest = max(np.max(nt),np.max(nf))
#m=largest / max(1,max(ns))
#noise = m*ns
seq_n.append(noise_win)
seq_X.append(self.inp_sig[wire][start:end] - mid + noise)
seq_y.append(self.answers[wire][start:end])
print "done with sequence generating"
self.train_X = []
self.train_y = []
self.train_n = []
for s_X, s_y, s_n in zip(seq_X, seq_y, seq_n):
for i in range(0, len(s_X) - self.window + 1):
self.train_X.append(s_X[i:i + self.window])
self.train_y.append(s_y[i:i + self.window])
self.train_n.append(s_n[i:i + self.window])
print "done with training data generation"
print len(self.train_X), len(self.train_y), len(self.train_n)
def process(inp,size):
print inp
num_samples = sr.get_num_samples(inp[0])
d_range = sr.get_ranges(inp[3]) # ,num_samples,size)
#print num_samples, d_range.size
f_sig = open(inp[0],'r')
f_nt = open(inp[1],'r')
f_nf = open(inp[2],'r')
print 'start reads'
d_sig = np.fromfile(f_sig,dtype=int,sep=' ')
print 'done with sig'
d_nt = np.fromfile(f_nt,dtype=int,sep=' ')
print 'done with np'
d_nf = np.fromfile(f_nf,dtype=int,sep=' ')
print 'done with nf'
d_sig.shape = ( d_sig.size/num_samples,num_samples )
d_nt.shape = ( d_nt.size/num_samples,num_samples )
d_nf.shape = ( d_nf.size/num_samples,num_samples )
d_only_nt = d_nt - d_sig
d_only_nf = d_nf - d_sig
def func(a,dset):
b=np.zeros(size,dtype=long)
start=a[1]
end=a[2]
offset=(size/2)-(end-start+1)/2
b[(offset):(offset+end-start)]=dset[a[0]][ start:end ]-a[5]
return b
def func_with_nt(a):
return func(a,d_sig) + func(a,d_nt)
def func_with_nf(a):
return func(a,d_sig) + func(a,d_nf)
def func_with_both(a):
return func(a,d_sig) + func(a,d_nf) + func(a,d_nt)
def func_answers(a):
return func(a,d_sig) != 0
# this works for the close and smaller than 50 intervals
all_answers=np.apply_along_axis(func_answers,1,d_range)
all_both=np.apply_along_axis(func_with_both,1,d_range)
all_nt=np.apply_along_axis(func_with_nt,1,d_range)
all_nf=np.apply_along_axis(func_with_nf,1,d_range)
rstart=10
rend=14
print all_nf[rstart:rend]
print all_nt[rstart:rend]
print all_both[rstart:rend]
print all_answers[rstart:rend]
all_nf.tofile(open('all_'+inp[2],'w'),sep=' ',format="%d")
all_nt.tofile(open('all_'+inp[1],'w'),sep=' ',format="%d")
all_both.tofile(open('all_'+inp[0],'w'),sep=' ',format="%d")
all_answers.tofile(open('all_'+inp[0],'w'),sep=' ',format="%d")
sys.exit(0)
def process(inp, size):
print inp
num_samples = sr.get_num_samples(inp[0])
d_range = sr.get_ranges(inp[3]) # ,num_samples,size)
#print num_samples, d_range.size
f_sig = open(inp[0], 'r')
f_nt = open(inp[1], 'r')
f_nf = open(inp[2], 'r')
print 'start reads'
d_sig = np.fromfile(f_sig, dtype=int, sep=' ')
print 'done with sig'
d_nt = np.fromfile(f_nt, dtype=int, sep=' ')
print 'done with np'
d_nf = np.fromfile(f_nf, dtype=int, sep=' ')
print 'done with nf'
d_sig.shape = (d_sig.size / num_samples, num_samples)
d_nt.shape = (d_nt.size / num_samples, num_samples)
d_nf.shape = (d_nf.size / num_samples, num_samples)
d_only_nt = d_nt - d_sig
d_only_nf = d_nf - d_sig
def func(a, dset):
b = np.zeros(size, dtype=long)
start = a[1]
end = a[2]
offset = (size / 2) - (end - start + 1) / 2
b[(offset):(offset + end - start)] = dset[a[0]][start:end] - a[5]
return b
def func_with_nt(a):
return func(a, d_sig) + func(a, d_nt)
def func_with_nf(a):
return func(a, d_sig) + func(a, d_nf)
def func_with_both(a):
return func(a, d_sig) + func(a, d_nf) + func(a, d_nt)
def func_answers(a):
return func(a, d_sig) != 0
# this works for the close and smaller than 50 intervals
all_answers = np.apply_along_axis(func_answers, 1, d_range)
all_both = np.apply_along_axis(func_with_both, 1, d_range)
all_nt = np.apply_along_axis(func_with_nt, 1, d_range)
all_nf = np.apply_along_axis(func_with_nf, 1, d_range)
rstart = 10
rend = 14
print all_nf[rstart:rend]
print all_nt[rstart:rend]
print all_both[rstart:rend]
print all_answers[rstart:rend]
all_nf.tofile(open('all_' + inp[2], 'w'), sep=' ', format="%d")
all_nt.tofile(open('all_' + inp[1], 'w'), sep=' ', format="%d")
all_both.tofile(open('all_' + inp[0], 'w'), sep=' ', format="%d")
all_answers.tofile(open('all_' + inp[0], 'w'), sep=' ', format="%d")
sys.exit(0)
def __init__(self, run_num, plane, window):
no_noise = "%s_sig_no_noise_%s.csv"%(run_num,plane)
ranges = "sig_%s_sig_no_noise_%s.csv"%(run_num,plane)
time_noise = "%s_sig_time_noise_%s.csv"%(run_num,plane)
freq_noise = "%s_sig_freq_noise_%s.csv"%(run_num,plane)
win_fraction = 5
self.window=window
self.run_num = run_num
self.plane = plane
print "getting range info",ranges
self.num_samples = sr.get_num_samples(no_noise)
self.d_range = sr.get_ranges(ranges)
self.inp_sig = self.get_data(no_noise)
self.inp_noise_time = self.get_data(time_noise)
self.inp_noise_freq = self.get_data(freq_noise)
print "done with data reading"
self.d_only_nt = self.inp_noise_time - self.inp_sig
self.d_only_nf = self.inp_noise_freq - self.inp_sig
print "done with noise calc"
self.answers = np.zeros(self.inp_sig.size,dtype=np.bool_)
self.answers.shape = self.inp_sig.shape
for r in self.d_range: self.answers[r[0]][r[1]:r[2]]=True
print "done with setting answers"
seq_X = []
seq_y = []
seq_n = []
ns=(self.d_only_nt,self.d_only_nf)
for r in self.d_range:
wire=r[0]
mid=r[5]
start=max(r[1]-(self.window/win_fraction), 0)
end=min(r[2]+self.window/win_fraction, self.num_samples)
if end-start < self.window:
# the window is too small, make it bigger
if start < self.window: end = start+self.window
else: start=end-self.window
rstart=np.random.randint(0,high=self.num_samples-(end-start))
rend=rstart+(end-start)
noise_win = ns[np.random.randint(2)][wire][rstart:rend]
noise = ns[np.random.randint(2)][wire][start:end]
#nt = self.d_only_nt[wire][start:end]
#nf = self.d_only_nf[wire][start:end]
#ns = nt #+nf
#largest = max(np.max(nt),np.max(nf))
#m=largest / max(1,max(ns))
#noise = m*ns
seq_n.append(noise_win)
seq_X.append( self.inp_sig[wire][start:end]-mid + noise )
seq_y.append( self.answers[wire][start:end] )
print "done with sequence generating"
self.train_X = []
self.train_y = []
self.train_n = []
for s_X,s_y,s_n in zip(seq_X,seq_y,seq_n):
for i in range(0,len(s_X)-self.window+1):
self.train_X.append(s_X[i:i+self.window])
self.train_y.append(s_y[i:i+self.window])
self.train_n.append(s_n[i:i+self.window])
print "done with training data generation"
print len(self.train_X),len(self.train_y), len(self.train_n)
