def main():
import doctest
doctest.testmod() # ...
# ...
x_blue = np.random.normal(loc=0, size=num_samples)
y_blue = np.random.normal(loc=0, scale=0.5, size=num_samples)
x_red = np.random.normal(loc=2, size=num_samples)
y_red = np.random.normal(loc=2, scale=0.5, size=num_samples)
data = list(zip(zip(x_blue, y_blue), [labels[0]] * num_samples))
data += zip(zip(x_red, y_red), [labels[1]] * num_samples)
np.random.shuffle(data) # ...
train_set = data[:train_size]
test_set = data[train_size:]
# Matplotlib craziness to be able to update a plot
plt.ion()
fig = plt.figure()
subplot = fig.add_subplot(1,1,1, xlim=(-5,5), ylim=(-5,5))
subplot.grid()
subplot.plot(x_blue, y_blue, linestyle='None', marker='o', color='blue')
subplot.plot(x_red, y_red, linestyle='None', marker='o', color='red')
p = Perceptron(2)
p.train(train_set, test_set, subplot=subplot, fig=fig)
def task3(fn_t, fn_tmdt, c):
'''demonstration'''
L = 1000 #length, using boundary condition u(x+L)=u(x)
dx = 1.
dt = 0.5
t_max = 100
#c = -10
b = (c*dt/dx)**2
#init fields
x = arange(0,L+dx/2.,dx) #[0, .... , L], consider 0 = L
#starting conditions
field_t = fn_t(x,dt) #starting condition at t0
field_tmdt = fn_tmdt(x,dt) #starting condition at t0-dt
eq1 = wave_eq_simple(field_t, field_tmdt, b)
plt.ion()
plot, = plt.plot(x, field_t)
for t in arange(0,t_max,dt):
print 'outer loop, t=',t
eq1.step()
plot.set_ydata(eq1.u)
plt.draw()
def __init__(self,name, sim, delay=None, G=None):
Process.__init__(self, name, sim)
self.G=G
if delay:
self.tstep=delay
elif not G: #two ways to give delay info.
raise Exception('PlotWorld needs information about the delay..')
else:
self.tstep=G.plotDelay #this stuff should already have been handled in simextend, but we take care of it anyway.
if not self.sim.anim and self.tstep < 1e5: #default is like 1e10..
plt.ion()
self.fig = plt.figure()
#look for monitors.
try:
self.sim.plotMoni() #will throw an exception if specified since arguments are not given.
monImpl=False
except TypeError:
monImpl=True
if self.G.noMonitors or (not monImpl):
self.ax1 = self.fig.add_subplot(111,aspect='equal', axisbg='#A2CD5A')
self.ax2=None #not implemented in Simulation. See tools.simextend for instructions.
self.ax3=None
self.ax4=None
else:
self.ax1 = self.fig.add_subplot(121,aspect='equal', axisbg='#A2CD5A')
self.ax2 = self.fig.add_subplot(322)
self.ax3 = self.fig.add_subplot(324)
self.ax4 = self.fig.add_subplot(326)
if self.sim.anim:
if not os.path.exists('animtemp'):
os.makedirs('animtemp')
def mask_spectrum(flux_to_fit,interactive=True,mask_lower_limit=None,mask_upper_limit=None):
"""
Interactively and iteratively creates a Boolean mask for a spectrum.
"""
if interactive:
plt.ion()
continue_parameter = 'no'
mask_switch = 'yes'
while mask_switch == 'yes':
pixel_array = np.arange(len(flux_to_fit))
plt.figure()
plt.step(pixel_array,flux_to_fit)
mask_lower_limit_string = raw_input("Enter mask lower limit (in pixels): ")
mask_lower_limit = float(mask_lower_limit_string)
mask_upper_limit_string = raw_input("Enter mask upper limit (in pixels): ")
mask_upper_limit = float(mask_upper_limit_string)
mask = (pixel_array >= mask_lower_limit) & (pixel_array <= mask_upper_limit)
flux_to_fit_masked = np.ma.masked_where(mask,flux_to_fit)
plt.step(pixel_array,flux_to_fit_masked)
continue_parameter = raw_input("Happy? (yes or no]): ")
plt.close()
if continue_parameter == 'yes':
mask_switch = 'no'
else:
pixel_array = np.arange(len(flux_to_fit))
mask = (pixel_array >= mask_lower_limit) & (pixel_array <= mask_upper_limit)
return mask
def task1():
'''demonstration'''
#TASK 0: Demo
L = 1000 #length, using boundary condition u(x+L)=u(x)
dx = 1.
dt = 0.1
t_max = 100
c = +10
b = (c*dt/dx)**2
#init fields
x = arange(0,L+dx/2.,dx) #[0, .... , L], consider 0 = L
#starting conditions
field_t = exp(-(x-10)**2) #starting condition at t0
field_tmdt = exp(-(x-c*dt-10)**2) #starting condition at t0-dt
eq1 = wave_eq(field_t, field_tmdt, b)
plt.ion()
plot, = plt.plot(x, field_t)
for t in arange(0,t_max,dt):
print 'outer loop, t=',t
eq1.step()
plot.set_ydata(eq1.u)
plt.draw()
def __init__(self, analogData): # set plot to animated plt.ion() self.axline, = plt.plot(analogData.ax) self.ayline, = plt.plot(analogData.ay) self.plt = plt plt.ylim([-2,2])
def Visualize(self,path=None,filename=None,viz_type='difference'): if path is None: path = self.result_path if filename is None: filename = '/results' im = [] if self.n<=1: fig = mpl.figure() x = np.linspace(0,1,self.m) counter = 1 for step in sorted(glob.glob(path+filename+'*.txt')): tmp = np.loadtxt(step) if viz_type=='difference': im.append(mpl.plot(x,(self.exact(x,np.zeros(self.m),counter*self.dt)-tmp),'b-')) else: im.append(mpl.plot(x,tmp,'b-')) counter += 1 ani = animation.ArtistAnimation(fig,im) mpl.show() else: X,Y = np.meshgrid(np.linspace(0,1,self.m),np.linspace(0,1,self.n)) mpl.ion() fig = mpl.figure() ax = fig.add_subplot(111,projection='3d') counter = 1 for step in sorted(glob.glob(path+filename+'*.txt')): tmp = np.loadtxt(step) wframe = ax.plot_wireframe(X,Y,(self.exact(X,Y,(counter*self.dt))-tmp)) mpl.draw() if counter==1: pass # ax.set_autoscaley_on(False) ax.collections.remove(wframe) counter +=1
def _create_figure(self, data=None, x=None, redraw=True, manual=False):
if self.parent is None:
pyplot.ion() # Must be here
kwds = {}
if self.figsize is not None:
kwds['figsize'] = self.figsize
self.figure = pyplot.figure(**kwds) # num=X
if self.padding is not None:
self.figure.subplots_adjust(**self.padding)
self.title = self.figure.suptitle(self.title_text)
if manual == False:
self.subplot = self.figure.add_subplot(self.pos)
else:
self.subplot = self.parent.figure.add_subplot(self.pos)
if self.subplot is not None:
self.subplot.grid(True)
self.subplot.set_title(self.sub_title_text)
if x is None:
#x = numpy.array([0])
#if self.x_range is None and data is not None:
# self._calc_x_range(data)
#if self.x_range is not None:
# x = numpy.linspace(self.x_range[0], self.x_range[1], self.x_range[1]-self.x_range[0])
#pass
if data is not None:
self._calc_x_range(data)
x = numpy.linspace(self.x_range[0], self.x_range[1], len(data[0]))
else:
self.x_range = (min(x), max(x)) # FIXME: Only if x_range is not None?
#if data is None:
# data = numpy.array([0]*len(x))
if not isinstance(data, list):
data = [data]
if data is not None and x is not None:
#self.plot, = pyplot.plot(x, data)
#self.plot, = self.subplot.plot(x, data)
#self.plots += self.subplot.plot([(x, _y) for _y in data]) # FIXME
for d in data:
self.plots += self.subplot.plot(x, d)
# This was moved left one indent level ('_apply_axis_limits' is safe)
#self.plot.axes.grid(True)
#self.plot.axes.set_title(self.sub_title_text)
#self.plot.axes.set_xlim([min(x),max(x)])
self._apply_axis_limits()
if redraw:
self._redraw()
def plot_goals(self):
fig = plt.figure()
#fig = plt.gcf()
fig.set_size_inches(14,11,forward=True)
ax = fig.add_subplot(111, projection='3d')
X = self.clustered_goal_data[:,0,3]
Y = self.clustered_goal_data[:,1,3]
Z = self.clustered_goal_data[:,2,3]
#print X,len(X),Y,len(Y),Z,len(Z)
c = 'b'
surf = ax.scatter(X, Y, Z,s=40, c=c,alpha=.5)
#surf = ax.scatter(X, Y,s=40, c=c,alpha=.6)
ax.set_xlabel('X Axis')
ax.set_ylabel('Y Axis')
ax.set_zlabel('Z Axis')
ax.set_title(''.join(['Plot of goals from ',self.subject,'. Data: (',str(self.data_start),' - ',str(self.data_finish),')']))
#fig.colorbar(surf, shrink=0.5, aspect=5)
rospack = rospkg.RosPack()
pkg_path = rospack.get_path('hrl_base_selection')
ax.set_xlim(-.2,.2)
ax.set_ylim(-.2,.2)
ax.set_zlim(-.2,.2)
#plt.savefig(''.join([pkg_path, '/images/goals_plot_',self.model,'_',self.subject,'_numbers_',str(self.data_start),'_',str(self.data_finish),'.png']), bbox_inches='tight')
plt.ion()
plt.show()
ut.get_keystroke('Hit a key to proceed next')
def doLeutiEvaluation(self, figureId=-1):
if len(self.plotLeutiDistances) > 0:
plt.ion()
plt.show(block=False)
if figureId == -1:
figure()
elif figureId >= 0:
figure(figureId)
spacings = self.plotLeutiDistances
if self.leutiSpacing > 0:
spacings = np.ones(len(self.plotLeutiDistances)) * self.leutiSpacing
leutiOutputPos, leutiOutputAtt, leutiOutputYaw, leutiOutputIncl = self.td.computeLeutiScore(
"pos", "att", "vel", self.tdgt, "pos", "att", self.plotLeutiDistances, spacings, 0.0
)
p = np.arange(len(self.plotLeutiDistances))
if figureId >= -1:
boxplot(leutiOutputPos, positions=p, widths=0.8)
ax = axes()
ax.set_xticklabels(self.plotLeutiDistances)
ax.set_xlabel("Travelled Distance [m]")
ax.set_ylabel("Position Error [m]")
med = np.zeros(len(leutiOutputPos))
for i in range(len(leutiOutputPos)):
med[i] = median(leutiOutputPos[i])
s = np.array(self.plotLeutiDistances) ** 0.5
score = s.dot(med) / s.dot(s)
fit = score * s
if figureId >= -1:
plot(p, fit)
title("Error Plot for Position, score = " + str(score))
return [leutiOutputPos, leutiOutputAtt, leutiOutputYaw, leutiOutputIncl, score]
def ToSVGString(graph):
"""
Convert as SVG file.
Parameters
----------
graph : object
A Graph or Drawable object.
Returns a SVG representation as string
"""
if sys.version_info[0] >= 3:
output = io.StringIO()
else:
output = io.BytesIO()
# save interactive mode state
ision = plt.isinteractive()
plt.ioff()
view = View(graph)
view.save(output, format='svg')
view.close()
# restore interactive mode state
if ision:
plt.ion()
return output.getvalue()
def __init__(self, model, n_rows, n_cols):
plt.ion()
self.n_rows, self.n_cols = n_rows, n_cols
self.n_comp = model.W.shape[1]
self.sub_rows, self.sub_columns = self.determine_subplots()
self.figure, self.axes = plt.subplots(self.sub_rows, self.sub_columns)
self.figure.suptitle(u"Loss and components -- NMF w/ {0}".format(model.loss_name), size=10)
self.ax_loss = self.axes[0, 0]
self.ax_loss.set_title(u"Loss", size=8)
self.lines, = self.ax_loss.plot([], [], u'o')
self.images = []
for i in range(self.sub_rows * self.sub_columns - 1):
sub_i, sub_j = (1 + i) % self.sub_rows, (1 + i) / self.sub_rows
subplot = self.axes[sub_i, sub_j]
if i < self.n_comp:
self.images.append(subplot.imshow(self.prepare_image(model.W[:, i]), cmap=u"Greys"))
subplot.set_title(u"W[:, %d]" % i, size=8)
subplot.set_axis_off()
else:
# Disable empty subplots
subplot.set_visible(False)
self.ax_loss.set_autoscaley_on(True)
self.ax_loss.set_xlim(0, model.iterations)
self.ax_loss.grid()
self.ax_loss.get_xaxis().set_visible(False)
self.ax_loss.get_yaxis().set_visible(False)
def main():
conn = krpc.connect()
vessel = conn.space_center.active_vessel
streams = init_streams(conn,vessel)
print vessel.control.throttle
plt.axis([0, 100, 0, .1])
plt.ion()
plt.show()
t0 = time.time()
timeSeries = []
vessel.control.abort = False
while not vessel.control.abort:
t_now = time.time()-t0
tel = Telemetry(streams,t_now)
timeSeries.append(tel)
timeSeriesRecent = timeSeries[-40:]
plt.cla()
plt.semilogy([tel.t for tel in timeSeriesRecent], [norm(tel.angular_velocity) for tel in timeSeriesRecent])
#plt.semilogy([tel.t for tel in timeSeriesRecent[1:]], [quat_diff_test(t1,t2) for t1,t2 in zip(timeSeriesRecent,timeSeriesRecent[1:])])
#plt.axis([t_now-6, t_now, 0, .1])
plt.draw()
plt.pause(0.0000001)
#time.sleep(0.0001)
with open('log.json','w') as f:
f.write(json.dumps([tel.__dict__ for tel in timeSeries],indent=4))
print 'The End'
def plot_tree(self, root=None, **kwargs):
"""
Draw branches
"""
if root and not self.root:
self.set_root(root)
if self.interactive: pyplot.ioff()
self.yaxis.set_visible(False)
self.create_branch_artists()
self.mark_named()
## self.home()
self.set_name(self.name)
self.adjust_xspine()
if self.interactive: pyplot.ion()
def fmt(x, pos=None):
if x<0: return ""
return ""
#self.yaxis.set_major_formatter(FuncFormatter(fmt))
return self
def wrapper(*args, **kwargs):
try:
plt.ion()
return func(*args, **kwargs)
finally:
plt.close("all")
plt.ioff()
def draw(arrayin):
array = np.abs(arrayin)
plt.clf()
plt.ion()
plt.imshow(array) #,cmap='Greys_r')
plt.axis('off')
plt.draw()
def complexHist(array): """Display the points (array) on a real and imaginary axis.""" from matplotlib.ticker import NullFormatter # scale the amplitudes to 0->1024 arrayAmp = np.abs(array)/np.max(np.abs(array)) #arrayAmp = arrayAmp - np.min(arrayAmp) #arrayAmp = arrayAmp / np.max(arrayAmp) arrayAmp = 1000.0*arrayAmp/(1000.0*arrayAmp + 1) array2 = arrayAmp * np.exp(-1.0J * np.angle(array)) x = [] y = [] for i in range(1000): i = random.randrange(0,array.shape[1]) j = random.randrange(0,array.shape[0]) x.append(array2.real[i,j]) y.append(array2.imag[i,j]) plt.clf() plt.ion() rect_scatter = [0.0,0.0,1.0,1.0] axScatter = plt.axes(rect_scatter) axScatter.scatter(x,y,s=1,c='grey',marker='o') axScatter.set_xlim((-1.0,1.0)) axScatter.set_ylim((-1.0,1.0)) #plt.plot(x,y,'k,') plt.draw()
def omori_tahir_dist(alpha=.5, beta=.5):
#
# plot an omori_x + poisson_tahir type figure
#
X=numpy.arange(0., 30., .1)
norm_fact = alpha+beta
alpha /= norm_fact
beta /= norm_fact
#
Y_omori_x = [omori_x(x) for x in X] #omori_x(X)
Y_poisson_x = [poisson_x(x) for x in X] # poisson_x(X)
#
YY = alpha*numpy.array(Y_omori_x) + beta*numpy.array(Y_poisson_x)
#
myplot=plt.loglog
#
plt.ion()
plt.figure(0)
plt.clf()
myplot(X, Y_omori_x, label='Aftershock Seismicity', lw=3)
myplot(X, Y_poisson_x, label='Largest Aftershock', lw=3)
myplot(X, YY, label = 'combined, $\\alpha = %.2f$, $\\beta = %.2f$' % (alpha, beta), lw=3)
#
plt.legend(loc=0, numpoints=1)
plt.xlabel('\'Normalized\' distance, $r/r_0$', size=16)
plt.ylabel('Seismic Hazard', size=16)
def show_vector(dx, dy, arr = None, w=None, h=None, skip=6, holdon=False):
if w is None or h is None:
h = dx.shape[0]
w = dx.shape[1]
import matplotlib.pyplot as plt
x, y = np.meshgrid(np.linspace(0, w, w), np.linspace(0, h, h))
ax = plt.axes(xlim=(0, w), ylim=(0, h))
line, = plt.plot(0,0,'ro')
plt.ion()
plt.ylim([0, h])
if skip is None:
ax.quiver(x, y, dx, dy)
else:
skip = (slice(None, None, skip), slice(None, None, skip))
ax.quiver(x[skip], y[skip], dx[skip], dy[skip])
if arr is not None:
plt.imshow(arr, cmap=plt.cm.Greys_r)
if holdon is True:
plt.draw()
plt.pause(0.0001)
return line, plt
else:
plt.show()
def process_statspecs(directive, part=None, designname=None):
"""
Main processor for the staplestatter directive. Responsible for:
1) Initialize figure and optionally axes as specified by the directive instructions.
2) Loop over all statspecs and call process_statspec.
3) Aggregate and return a list of stats/scores.
"""
if part is None:
part = cadnano_api.p()
if designname is None:
designname = os.path.splitext(os.path.basename(part.document().controller().filename()))[0]
print("designname:", designname)
statspecs = directive['statspecs']
figspec = directive.get('figure', dict())
if figspec.get('newfigure', False) or len(pyplot.get_fignums()) < 1:
fig = pyplot.figure(**figspec.get('figure_kwargs', {}))
else:
fig = pyplot.gcf() # Will make a new figure if no figure has been created.
# Here you can add more "figure/axes" specification logic:
adjustfuncs = ('title', 'size_inches', 'dpi')
for cand in adjustfuncs:
if cand in figspec and figspec[cand]:
getattr(fig, 'set_'+cand)(figspec[cand]) # equivalent to fig.title(figspec['title'])
pyplot.ion()
allscores = list()
for _, statspec in enumerate(statspecs):
scores = process_statspec(statspec, part=part, designname=designname, fig=fig)
allscores.append(scores)
if 'printspec' in statspec:
print("Printing highest scores with: statspec['printspec']")
get_highest_scores(scores, **statspec['printspec']) # This logic is subject to change.
return dict(figure=fig, scores=allscores)
def makeDisplay():
plt.ion()
fig = plt.figure(figsize=(10, 12))
layout = fig.add_subplot(211)
plt.ylabel("x position + 10*conc")
plt.xlabel("y position (microns)")
timeLabel = plt.text(0, 20, "time = 0")
layout.set_xlim(-5, 75)
layout.set_ylim(-20, 25)
compt = moose.element("/model/chem/compt0")
pos = compt.voxelMidpoint
i = len(pos) / 3
r2 = numpy.sqrt(0.5)
yp = [-r2 * pos[j] * 1e6 for j in range(i)]
xp = pos[i : 2 * i] * 1e6 - yp
# xp = [ pos[i + j] for j in range( i ) ]
# yp = [ -r2 * pos[j] for j in range( i ) ]
# line0, = layout.plot( pos[:i], pos[i:2*i] , 'bo' )
line, = layout.plot(xp, yp, "bo")
timeSeries = fig.add_subplot(212)
timeSeries.set_ylim(0, 0.6)
plt.ylabel("Conc (mM)")
plt.xlabel("time (seconds)")
fig.canvas.draw()
return (timeSeries, fig, line, timeLabel, yp)
def plotsolution(numnodes,coordinates,routes):
plt.ion() # interactive mode on
G=nx.Graph()
nodes = range(1,numnodes+1)
nodedict = {}
for i in nodes:
nodedict[i] = i
nodecolorlist = ['b' for i in nodes]
nodecolorlist[0] = 'r'
# nodes
nx.draw_networkx_nodes(G, coordinates, node_color=nodecolorlist, nodelist=nodes)
# labels
nx.draw_networkx_labels(G,coordinates,font_size=9,font_family='sans-serif',labels = nodedict)
edgelist = defaultdict(list)
colors = ['Navy','PaleVioletRed','Yellow','Darkorange','Chartreuse','CadetBlue','Tomato','Turquoise','Teal','Violet','Silver','LightSeaGreen','DeepPink', 'FireBrick','Blue','Green']
for i in (routes):
edge1 = 1
for j in routes[i][1:]:
edge2 = j
edgelist[i].append((edge1,edge2))
edge1 = edge2
nx.draw_networkx_edges(G,coordinates,edgelist=edgelist[i],
width=6,alpha=0.5,edge_color=colors[i]) #,style='dashed'
plt.savefig("path.png")
plt.show()
def __init__(self,master,title):
Toplevel.__init__(self,master)
self.master = master
from __init__ import MATPLOTLIB_BACKEND
if MATPLOTLIB_BACKEND != None:
print "manipulator: Setting matplotlib backend to \"TkAgg\"."
import matplotlib
matplotlib.use("TkAgg")
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from matplotlib.figure import Figure
from matplotlib import pyplot
self.title(title)
self.resizable(True,True)
self.fig = pyplot.figure()
pyplot.ion()
self.canvas = FigureCanvasTkAgg(self.fig, master=self)
self.canvas.show()
self.canvas.get_tk_widget().pack(side=TOP, fill=BOTH, expand=1)
self.canvas._tkcanvas.pack(side=TOP, fill=BOTH, expand=1)
self.update()
self.experiments = []
def streamVisionSensor(visionSensorName,clientID,pause=0.0001):
#Get the handle of the vision sensor
res1,visionSensorHandle=vrep.simxGetObjectHandle(clientID,visionSensorName,vrep.simx_opmode_oneshot_wait)
#Get the image
res2,resolution,image=vrep.simxGetVisionSensorImage(clientID,visionSensorHandle,0,vrep.simx_opmode_streaming)
#Allow the display to be refreshed
plt.ion()
#Initialiazation of the figure
time.sleep(0.5)
res,resolution,image=vrep.simxGetVisionSensorImage(clientID,visionSensorHandle,0,vrep.simx_opmode_buffer)
im = I.new("RGB", (resolution[0], resolution[1]), "white")
#Give a title to the figure
fig = plt.figure(1)
fig.canvas.set_window_title(visionSensorName)
#inverse the picture
plotimg = plt.imshow(im,origin='lower')
#Let some time to Vrep in order to let him send the first image, otherwise the loop will start with an empty image and will crash
time.sleep(1)
while (vrep.simxGetConnectionId(clientID)!=-1):
#Get the image of the vision sensor
res,resolution,image=vrep.simxGetVisionSensorImage(clientID,visionSensorHandle,0,vrep.simx_opmode_buffer)
#Transform the image so it can be displayed using pyplot
image_byte_array = array.array('b',image)
im = I.frombuffer("RGB", (resolution[0],resolution[1]), image_byte_array, "raw", "RGB", 0, 1)
#Update the image
plotimg.set_data(im)
#Refresh the display
plt.draw()
#The mandatory pause ! (or it'll not work)
plt.pause(pause)
print 'End of Simulation'
def plot_server():
rospy.init_node('plotter')
s = rospy.Service('plot', Plot, handle_plot)
plt.ion()
print "Ready to plot things!", plt.isinteractive()
rospy.spin()
def follow_channels(self, channel_list):
"""
Tracks and plots a specified set of channels in real time.
Parameters
----------
channel_list : list
A list of the channels for which data has been requested.
"""
if not pyplot_available:
raise ImportError('pyplot needs to be installed for '
'this functionality.')
plt.clf()
plt.ion()
while True:
self.update_channels(channel_list)
plt.clf()
for channel_name in self.channels:
plt.plot(
self.channels[channel_name].epoch_record,
self.channels[channel_name].val_record,
label=channel_name
)
plt.legend()
plt.ion()
plt.draw()
def __init__(self):
self.map = np.loadtxt('wean.dat', delimiter=' ')
self.occ = np.loadtxt('occu.dat', delimiter=' ')
self.unocc = np.loadtxt('unoccu.dat', delimiter=' ')
self.unocc_dict = {tuple(el):1 for el in self.unocc}
self.unocc_corr = np.loadtxt('unoccu_corr.dat', delimiter=' ')
#self.X_t = np.loadtxt('part_init.dat', delimiter=' ')
self.num_p = 1e4
self.sense = np.loadtxt('sense4.dat', delimiter=' ')
self.isodom = np.loadtxt('is_odom4.dat', delimiter=' ')
self.mindist = np.loadtxt('min_d.dat', delimiter=' ')
self.a = np.array([.01,.01,0.01,0.01])
self.c_lim = 10
self.lsr_max = 1000
self.zmax = 0.25
self.zrand = 0.25
self.sig_h = 5
self.zhit = .75
self.q = 1
self.srt = 10
self.end = 170
self.step = 10
plt.imshow(self.map)
plt.ion()
self.scat = plt.quiver(0,0,1,0)
def plot_astcat(infile, astcat, rmarker=10., racol=0, deccol=1, hext=0):
# Turn on interactive, so that plot occurs first and then query
plt.ion()
""" Load fits file """
fitsim = im.Image(infile)
hdr = fitsim.hdulist[hext].header
""" Select astrometric objects within the FOV of the detector """
mra,mdec,mx,my,astmask = select_good_ast(astcat,hdr,racol,deccol)
""" Plot the fits file and mark the astrometric objects """
fig = plt.figure(1)
fitsim.display(cmap='heat')
plt.plot(mx,my,'o',ms=rmarker,mec='g',mfc='none',mew=2)
plt.xlim(0,nx)
plt.ylim(0,ny)
plt.draw()
#cid = fig.canvas.mpl_connect('button_press_event', on_click)
"""
Be careful of the +1 offset between SExtractor pixels and python indices
"""
return fitsim
def plot_dataframe(data, error=False, log=False):
'''
plot data frame columns in a long plot
'''
try:
ioff()
fig, ax = plt.subplots(
(len(data.columns)), figsize=(10, 50), sharex=True)
close('all')
ion()
except:
print 'you may be in a non interactive environment'
if not error:
for i, j in zip(data.columns, ax):
if i != 'name':
j.plot(data.index, data[i].values)
j.set_ylabel(str(i))
if error:
for i, j in zip(data.columns, ax):
if i != 'name':
j.errorbar(
data.index, data[i].values, yerr=sqrt(data[i].values))
j.set_ylabel(str(i))
if log:
for i, j in zip(data.columns, ax):
if i != 'name':
j.set_yscale('log')
return fig, ax
def main():
print """Legend:
Yellow star\t -\t True position of robot
Blue arrows\t -\t Particle cloud
Yellow dots\t -\t Sonar pings
Green boxes\t -\t Obstacles
Red star\t -\t Goal"""
these_parameters = robot.Parameters(vel_max=1
, omega_max=0.1
, displacement_slowdown=5
, avoid_threshold=5
)
true_pose = (80, 90, pi)
this_goal = robot.Goal(location=(20, 20, 0)
, radius=3)
this_map = mapdef()
this_sonar = ogmap.Sonar(num_theta=20
, gauss_var=2
)
this_robot = RobotMapper(these_parameters
, this_sonar
)
this_robot.situate(this_map
, true_pose
, this_goal
)
plt.ion()
this_robot.automate(num_steps=10)
if robot.check_success(this_goal, this_robot):
print "SUCCESS"
else:
print "FAILURE"
def plot_bar_seq_stdev(barcode_frame,
notebook_dir,
experiment=None,
show_plots=True,
save_plots=False,
count_cutoff=500):
# Turn interactive plotting on or off depending on show_plots
if show_plots:
plt.ion()
else:
plt.ioff()
if save_plots:
pdf_file = 'barcode read standard deviation plot.pdf'
pdf = PdfPages(pdf_file)
data_directory = notebook_dir + "\\barcode_analysis"
os.chdir(data_directory)
if experiment is None:
experiment = get_exp_id(notebook_dir)
#Plot standard deviation of barcode read fractions (across wells in time point 1) vs mean read fraction
# data from 2019-10-02: #################################################################################
x_test = np.asarray([
0.23776345382258504, 0.21428834768303265, 0.14955568743012018,
0.10527042635253019, 0.08814193520270863, 0.07140559171457407,
0.032268913991628186, 0.02486533840744069, 0.009370452839984682,
0.0021539027931815613, 0.0001936817014361814
])
y_test = np.asarray([
0.0019726945744597706, 0.0028398295224567756, 0.0027140121666701543,
0.0016422861817864806, 0.0012364410886752844, 0.0014467832918787287,
0.0009412184378809117, 0.0007090217957749182, 0.00034552377974558844,
0.00017198555940160456, 4.958998052635534e-05
])
poisson_err_test = np.asarray([
0.001391130466104952, 0.001320415964490587, 0.0011032026255463198,
0.0009247685041703838, 0.0008466282838575875, 0.0007620910541483005,
0.0005123905962175842, 0.000449754496329767, 0.00027605091052578906,
0.0001323496187650663, 3.929704870026295e-05
])
#####################################################################################################
# data from 2019-10-08: #############################################################################
x_small = np.asarray([
0.08251274176535274, 0.0962239061597132, 0.08539004578198717,
0.08675701439383578, 0.07400424816228543, 0.07566109361860245,
0.0699367739242362, 0.06963680434271374, 0.06384195016208481,
0.06321931248609224, 0.06334894239678983, 0.02536420185939611,
0.03923343837910993, 0.020238576239101202
])
y_small = np.asarray([
0.003020200426682457, 0.003374150359051314, 0.00374541788260866,
0.0035764736646941536, 0.002598176841078495, 0.003669639858790278,
0.0021759993522437074, 0.002827475646549457, 0.0038335541520843315,
0.002201298340428577, 0.008012477386731139, 0.001454772893578839,
0.0012788004626381614, 0.0021763030793714206
])
poisson_err_small = np.asarray([
0.0008661333092282185, 0.0009340439480853888, 0.0008821889073372234,
0.0008856945951456786, 0.000820757229296616, 0.000830315430739499,
0.0007963057526756344, 0.0007963629310250612, 0.000763102677224598,
0.0007575749124137182, 0.0007546065015548847, 0.0004797418835729835,
0.000596486425619687, 0.00042833165436399073
])
##############################################################################################
fraction_list = ["fraction_" + w for w in wells_by_column()[:24]]
plt.rcParams["figure.figsize"] = [16, 8]
fig, axs = plt.subplots(1, 2)
#fig.suptitle('First Time Point Only (Plate 2)', fontsize=24, position=(0.5, 0.925))
axs[0].plot(x_test,
y_test,
"o",
ms=10,
label="Library Prep Test, 2019-10-02")
axs[0].plot(x_test, poisson_err_test, c="gray")
axs[0].plot(x_small,
y_small,
"o",
ms=10,
label="Small Library Selection, 2019-10-08")
axs[1].plot(x_test,
y_test / x_test,
"o",
ms=10,
label="Library Prep Test, 2019-10-02")
axs[1].plot(x_test, poisson_err_test / x_test, c="gray")
axs[1].plot(x_small,
y_small / x_small,
"o",
ms=10,
label="Small Library Selection, 2019-10-08")
f_data = barcode_frame[barcode_frame["total_counts"] > count_cutoff]
y = np.asarray(
[f_data[fraction_list].iloc[i].std() for i in range(len(f_data))])
x = np.asarray(
[f_data[fraction_list].iloc[i].mean() for i in range(len(f_data))])
err_est = np.asarray([
(f_data[fraction_list].iloc[i].mean()) /
(np.sqrt(f_data[wells_by_column()[:24]].iloc[i].mean()))
for i in range(len(f_data))
])
axs[0].plot(x, y, "o", ms=5, label=experiment)
axs[0].plot(x, err_est, c="darkgreen")
axs[0].set_ylabel('Stdev(barcode fraction per sample)', size=20)
axs[0].plot(x, y / x, "o", ms=5, label=experiment)
axs[0].plot(x, err_est / x, c="darkgreen")
axs[0].set_ylabel('Relative Stdev(barcode fraction per sample)', size=20)
for ax in axs.flatten():
ax.set_xlabel('Mean(barcode fraction per sample)', size=20)
ax.tick_params(labelsize=16)
ax.set_xscale("log")
ax.set_yscale("log")
leg = ax.legend(loc='upper left',
bbox_to_anchor=(0.025, 0.93),
ncol=1,
borderaxespad=0,
frameon=True,
fontsize=12)
leg.get_frame().set_edgecolor('k')
if save_plots:
pdf.savefig()
if not show_plots:
plt.close(fig)
if save_plots:
pdf.close()
from sweeppy import Sweep
import matplotlib.pyplot as plt
import math
import os
DEV = os.environ['SCANSE_SWEEP_PORT']
# Create figure:
fig1 = plt.figure(1)
# Clear figure:
plt.clf()
# Enable interactive mode:
plt.ion()
# Create polar subplot:
sbp = plt.subplot(111, projection='polar')
# Create axis:
ax = fig1.add_axes(sbp)
# Set radius limit:
ax.set_ylim(0, 600)
if __name__ == "__main__":
with Sweep(DEV) as sweep:
speed = sweep.get_motor_speed()
rate = sweep.get_sample_rate()
def _ml_t_marginal(self, assign_dates=False):
"""
Compute the marginal probability distribution of the internal nodes positions by
propagating from the tree leaves towards the root. The result of
this operation are the probability distributions of each internal node,
conditional on the constraints on all leaves of the tree, which have sampling dates.
The probability distributions are set as marginal_pos_LH attributes to the nodes.
Parameters
----------
assign_dates : bool, default False
If True, the inferred dates will be assigned to the nodes as
:code:`time_before_present' attributes, and their branch lengths
will be corrected accordingly.
.. Note::
Normally, the dates are assigned by running joint reconstruction.
Returns
-------
None
Every internal node is assigned the probability distribution in form
of an interpolation object and sends this distribution further towards the
root.
"""
def _cleanup():
for node in self.tree.find_clades():
try:
del node.marginal_pos_Lx
del node.subtree_distribution
del node.msg_from_parent
#del node.marginal_pos_LH
except:
pass
self.logger(
"ClockTree - Marginal reconstruction: Propagating leaves -> root...",
2)
# go through the nodes from leaves towards the root:
for node in self.tree.find_clades(
order='postorder'): # children first, msg to parents
if node.bad_branch:
# no information
node.marginal_pos_Lx = None
else: # all other nodes
if node.date_constraint is not None and node.date_constraint.is_delta: # there is a hard time constraint
# initialize the Lx for nodes with precise date constraint:
# subtree probability given the position of the parent node
# position of the parent node is given by the branch length
# distribution attached to the child node position
node.subtree_distribution = node.date_constraint
bl = node.branch_length_interpolator.x
x = bl + node.date_constraint.peak_pos
node.marginal_pos_Lx = Distribution(
x,
node.branch_length_interpolator(bl),
min_width=self.min_width,
is_log=True)
else: # all nodes without precise constraint but positional information
# subtree likelihood given the node's constraint and child msg:
msgs_to_multiply = [
node.date_constraint
] if node.date_constraint is not None else []
msgs_to_multiply.extend([
child.marginal_pos_Lx for child in node.clades
if child.marginal_pos_Lx is not None
])
# combine the different msgs and constraints
if len(msgs_to_multiply) == 0:
# no information
node.marginal_pos_Lx = None
continue
elif len(msgs_to_multiply) == 1:
node.subtree_distribution = msgs_to_multiply[0]
else: # combine the different msgs and constraints
node.subtree_distribution = Distribution.multiply(
msgs_to_multiply)
if node.up is None: # this is the root, set dates
node.subtree_distribution._adjust_grid(
rel_tol=self.rel_tol_prune)
node.marginal_pos_Lx = node.subtree_distribution
node.marginal_pos_LH = node.subtree_distribution
self.tree.positional_marginal_LH = -node.subtree_distribution.peak_val
else: # otherwise propagate to parent
res, res_t = NodeInterpolator.convolve(
node.subtree_distribution,
node.branch_length_interpolator,
max_or_integral='integral',
n_grid_points=self.node_grid_points,
n_integral=self.n_integral,
rel_tol=self.rel_tol_refine)
res._adjust_grid(rel_tol=self.rel_tol_prune)
node.marginal_pos_Lx = res
self.logger(
"ClockTree - Marginal reconstruction: Propagating root -> leaves...",
2)
from scipy.interpolate import interp1d
for node in self.tree.find_clades(order='preorder'):
## The root node
if node.up is None:
node.msg_from_parent = None # nothing beyond the root
# all other cases (All internal nodes + unconstrained terminals)
elif node.date_constraint is not None and node.date_constraint.is_delta:
node.marginal_pos_LH = node.date_constraint
else:
parent = node.up
# messages from the complementary subtree (iterate over all sister nodes)
complementary_msgs = [
sister.marginal_pos_Lx for sister in parent.clades
if (sister != node) and (
sister.marginal_pos_Lx is not None)
]
# if parent itself got smth from the root node, include it
if parent.msg_from_parent is not None:
complementary_msgs.append(parent.msg_from_parent)
if len(complementary_msgs):
msg_parent_to_node = NodeInterpolator.multiply(
complementary_msgs)
msg_parent_to_node._adjust_grid(rel_tol=self.rel_tol_prune)
else:
x = [parent.numdate, numeric_date()]
msg_parent_to_node = NodeInterpolator(
x, [1.0, 1.0], min_width=self.min_width)
# integral message, which delivers to the node the positional information
# from the complementary subtree
res, res_t = NodeInterpolator.convolve(
msg_parent_to_node,
node.branch_length_interpolator,
max_or_integral='integral',
inverse_time=False,
n_grid_points=self.node_grid_points,
n_integral=self.n_integral,
rel_tol=self.rel_tol_refine)
node.msg_from_parent = res
if node.marginal_pos_Lx is None:
node.marginal_pos_LH = node.msg_from_parent
else:
node.marginal_pos_LH = NodeInterpolator.multiply(
(node.msg_from_parent, node.subtree_distribution))
self.logger(
'ClockTree._ml_t_root_to_leaves: computed convolution'
' with %d points at node %s' % (len(res.x), node.name), 4)
if self.debug:
tmp = np.diff(res.y - res.peak_val)
nsign_changed = np.sum((tmp[1:] * tmp[:-1] < 0) &
(res.y[1:-1] - res.peak_val < 500))
if nsign_changed > 1:
import matplotlib.pyplot as plt
plt.ion()
plt.plot(res.x, res.y - res.peak_val, '-o')
plt.plot(
res.peak_pos - node.branch_length_interpolator.x,
node.branch_length_interpolator(
node.branch_length_interpolator.x) -
node.branch_length_interpolator.peak_val, '-o')
plt.plot(
msg_parent_to_node.x,
msg_parent_to_node.y - msg_parent_to_node.peak_val,
'-o')
plt.ylim(0, 100)
plt.xlim(-0.05, 0.05)
import ipdb
ipdb.set_trace()
# assign positions of nodes and branch length only when desired
# since marginal reconstruction can result in negative branch length
if assign_dates:
node.time_before_present = node.marginal_pos_LH.peak_pos
if node.up:
node.clock_length = node.up.time_before_present - node.time_before_present
node.branch_length = node.clock_length
# construct the inverse cumulant distribution to evaluate confidence intervals
if node.marginal_pos_LH.is_delta:
node.marginal_inverse_cdf = interp1d(
[0, 1],
node.marginal_pos_LH.peak_pos * np.ones(2),
kind="linear")
else:
dt = np.diff(node.marginal_pos_LH.x)
y = node.marginal_pos_LH.prob_relative(node.marginal_pos_LH.x)
int_y = np.concatenate(
([0], np.cumsum(dt * (y[1:] + y[:-1]) / 2.0)))
int_y /= int_y[-1]
node.marginal_inverse_cdf = interp1d(int_y,
node.marginal_pos_LH.x,
kind="linear")
node.marginal_cdf = interp1d(node.marginal_pos_LH.x,
int_y,
kind="linear")
if not self.debug:
_cleanup()
return
# package tests.beta scope global params import os import matplotlib.pyplot as plt plt.ion() # all beta/test_ plot disappear automatically # MTPY_ROOT='/Softlab/Githubz/mtpy' # source code root dir MTPY_ROOT='/g/data/ha3/fxz547/Githubz/mtpyclone' # source code root dir # MTPY_ROOT='E:/Githubz/mtpy' # source code root dir EDI_DATA_DIR = os.path.join(MTPY_ROOT,'examples/data/edi_files') EDI_DATA_DIR2 = os.path.join(MTPY_ROOT,'examples/data/edi_files_2') AUS_TOPO_FILE = os.path.join(MTPY_ROOT,'examples/data/AussieContinent_etopo1.asc') # path to directory containing model input files - samples reference for compare SAMPLE_DIR = os.path.join(MTPY_ROOT,'examples/model_files') # r'E:\Githubz\mtpy\examples\model_files' # test runs output directory where to save plots/files to TEMP_OUT_DIR = os.path.join(MTPY_ROOT,'temp/beta_out_dir') # r'E:\Githubz\mtpy\temp'
print('\nSecond dose administered per day(avg) :','{:,}'.format(math.ceil(secondDose/(len(IndiaVaccineData)-28))))
cur.execute('''insert into dose_distribution (state, first_dose, second_dose)
values ((%s),(%s),(%s)) on conflict(state) do update set first_dose = (%s), second_dose = (%s)''',
('Puducherry', firstDose, secondDose, firstDose, secondDose,))
conn.commit()
xPoints = ['First dose', 'Second dose']
yPoints = [firstDose, secondDose]
values = pd.DataFrame({'xPoints':xPoints, 'yPoints':yPoints})
pyplot.figure(figsize = (9,4))
pyplot.pie(yPoints, explode = (0,0.1), labels = xPoints, colors = ['yellow', 'orange'], autopct = '%1.1f%%', shadow = True)
pyplot.axis('equal')
pyplot.title('Doses administered')
pyplot.savefig(r'C:\Users\Mittu\Desktop\CovidDataAnalysis\Covid-Data-Analysis\Graphs\PuducherryDoses.png')
pyplot.ion()
pyplot.close()
xPoints = list(range(1,96))
yPoints = IndiaVaccineData['First Dose Administered'].sub(IndiaVaccineData['First Dose Administered'].shift())
yPoints = yPoints[1:]
pyplot.plot(xPoints, yPoints/1000)
pyplot.title('Daily administration of first dose')
pyplot.ylabel('First Dose Administered in thousands')
pyplot.xlabel('Days')
pyplot.savefig(r'C:\Users\Mittu\Desktop\CovidDataAnalysis\Covid-Data-Analysis\Graphs\PuducherryFirstDose.png')
pyplot.ion()
pyplot.close()
xPoints = list(range(1,96))
yPoints = IndiaVaccineData['Second Dose Administered'].sub(IndiaVaccineData['Second Dose Administered'].shift())
if j == i:
continue
result *= (x - x_vec[j]) / (x_vec[i] - x_vec[j])
return result
#the entire lagrangian
def L(x, x_vec, f_vec):
result = 0
for i in range(0, len(x_vec)):
result += f_vec[i] * l(i, x, x_vec)
return result
############################## GENERATING THE PLOT ############################
plt.ion() #turn interactive mode on
FIG = plt.figure("Slider Bar Lagrangian Plot Window") #create a global figure
AXES = FIG.add_subplot(111) #add a plot to it (because it was empty)
#and create a global axis handle
AXES.set_xlim(-10, 10)
AXES.set_ylim(-2, 2)
FINE = np.linspace(-10, 10, 200)
ARCTAN, = AXES.plot(FINE, [arctan(x) for x in FINE], 'k-', label='arctan(x)')
PRESETS = linspace(-10, 10, 6)
PRESET_F = [arctan(x) for x in PRESETS]
SAMPLE, = AXES.plot(PRESETS, [arctan(x) for x in PRESETS],
'ro',
label='sample')
LAGRANGIAN, = AXES.plot(FINE, [L(x, PRESETS, PRESET_F) for x in FINE],
'b-',
label='lagrangian')
def plot_barcode_fitness(barcode_frame,
notebook_dir,
experiment=None,
show_plots=True,
save_plots=False,
inducer_conc_list=None,
plot_range=None,
inducer="IPTG"):
if plot_range is not None:
barcode_frame = barcode_frame.iloc[plot_range[0]:plot_range[1]]
if experiment is None:
experiment = get_exp_id(notebook_dir)
if inducer_conc_list is None:
inducer_conc_list = [0, 2]
for i in range(10):
inducer_conc_list.append(2 * inducer_conc_list[-1])
# Turn interactive plotting on or off depending on show_plots
if show_plots:
plt.ion()
else:
plt.ioff()
if save_plots:
pdf_file = 'barcode fitness plots.pdf'
pdf = PdfPages(pdf_file)
data_directory = notebook_dir + "\\barcode_analysis"
os.chdir(data_directory)
#plot fitness curves
plt.rcParams["figure.figsize"] = [12, 8 * (len(barcode_frame))]
fig, axs = plt.subplots(len(barcode_frame), 1)
x = inducer_conc_list
linthreshx = min([i for i in inducer_conc_list if i > 0])
plot_colors = sns.color_palette()
for (index, row), ax in zip(barcode_frame.iterrows(),
axs): # iterate over barcodes
for initial in ["b", "e"]:
y = row[f"fitness_0_estimate_{initial}"]
s = row[f"fitness_0_err_{initial}"]
fill_style = "full" if initial == "b" else "none"
ax.errorbar(x,
y,
s,
marker='o',
ms=10,
color=plot_colors[0],
fillstyle=fill_style)
y = row[f"fitness_tet_estimate_{initial}"]
s = row[f"fitness_tet_err_{initial}"]
ax.errorbar(x,
y,
s,
marker='^',
ms=10,
color=plot_colors[1],
fillstyle=fill_style)
if initial == "b":
barcode_str = str(index) + ', '
barcode_str += str(row['total_counts']) + ", "
barcode_str += row['RS_name'] + ": "
barcode_str += row['forward_BC'] + ", "
barcode_str += row['reverse_BC']
ax.text(x=0.0,
y=1.03,
s=barcode_str,
horizontalalignment='left',
verticalalignment='top',
transform=ax.transAxes,
fontsize=12)
ax.set_xscale('symlog', linthreshx=linthreshx)
ax.set_xlim(-linthreshx / 10, 2 * max(x))
ax.set_xlabel(f'[{inducer}] (umol/L)', size=20)
ax.set_ylabel('Fitness (log(10)/plate)', size=20)
ax.tick_params(labelsize=16)
if save_plots:
pdf.savefig()
if not show_plots:
plt.close(fig)
if save_plots:
pdf.close()
def plot_bar_seq_read_fractions(barcode_frame,
notebook_dir,
experiment=None,
show_plots=True,
save_plots=False,
num_to_plot=None):
# Turn interactive plotting on or off depending on show_plots
if show_plots:
plt.ion()
else:
plt.ioff()
if save_plots:
pdf_file = 'barcode read fraction plots.pdf'
pdf = PdfPages(pdf_file)
data_directory = notebook_dir + "\\barcode_analysis"
os.chdir(data_directory)
if experiment is None:
experiment = get_exp_id(notebook_dir)
#Plot read fraction across all samples for first several barcodes
plt.rcParams["figure.figsize"] = [16, 6 * num_to_plot]
fig, axs = plt.subplots(num_to_plot, 1)
f_data = barcode_frame[:num_to_plot]
plot_colors = sns.hls_palette(12, l=.4, s=.8)
plot_colors12 = []
for c in plot_colors:
for i in range(8):
plot_colors12.append(c)
for index, row in f_data.iterrows():
y = []
x = []
y_for_scale = []
for i, t in enumerate(wells_by_column()):
y.append(row["fraction_" + t])
x.append(i + 1)
if (row["fraction_" + t]) > 0:
y_for_scale.append(row["fraction_" + t])
axs[index].scatter(x, y, c=plot_colors12, s=70)
axs[index].set_ylim(0.5 * min(y_for_scale), 2 * max(y))
axs[index].set_yscale("log")
barcode_str = str(index) + ', '
if row['RS_name'] != "": barcode_str += row['RS_name'] + ", "
barcode_str += row['forward_BC'] + ', ' + row['reverse_BC']
axs[index].text(x=0.05,
y=0.95,
s=barcode_str,
horizontalalignment='left',
verticalalignment='top',
transform=axs[index].transAxes,
fontsize=14)
for i in range(13):
axs[index].plot([i * 8 + 0.5, i * 8 + 0.5],
[0.6 * min(y_for_scale), 1.2 * max(y)],
color='gray')
axs[0].set_title("Read Fraction Per Barcode", fontsize=32)
if save_plots:
pdf.savefig()
if not show_plots:
plt.close(fig)
if save_plots:
pdf.close()
def __init__(self, n_feature, n_hidden, n_output):
super(Net, self).__init__()
self.hidden = torch.nn.Linear(n_feature, n_hidden) # hidden layer
self.out = torch.nn.Linear(n_hidden, n_output) # output layer
def forward(self, x):
x = F.relu(self.hidden(x)) # activation function for hidden layer
x = self.out(x)
return x
net = Net(n_feature=2, n_hidden=10, n_output=2)
optimizer = torch.optim.SGD(net.parameters(), lr=0.1)
loss_func = torch.nn.CrossEntropyLoss()
plt.ion() # something about plotting
for t in range(100):
out = net(x) # input x and predict based on x
loss = loss_func(
out, y
) # must be (1. nn output, 2. target), the target label is NOT one-hotted
optimizer.zero_grad() # clear gradients for next train
loss.backward() # backpropagation, compute gradients
optimizer.step() # apply gradients
if t % 2 == 0:
# plot and show learning process
plt.cla()
prediction = torch.max(out, 1)[1]
def bar_seq_threshold_plot(notebook_dir,
experiment=None,
save_plots=False,
cutoff=None,
hist_bin_max=None,
num_bins=50,
barcode_file=None):
# Turn interactive plotting on or off depending on show_plots
plt.ion()
if save_plots:
pdf_file = 'barcode histogram plot.pdf'
pdf = PdfPages(pdf_file)
#os.chdir(notebook_dir)
if experiment is None:
experiment = get_exp_id(notebook_dir)
print(
f"Importing BarSeq count data and plotting histogram for thresholding for experiment: {experiment}"
)
data_directory = notebook_dir + "\\barcode_analysis"
os.chdir(data_directory)
if barcode_file is None:
barcode_file = glob.glob("*.sorted_counts.csv")[0]
print(f"Importing BarSeq count data from file: {barcode_file}")
barcode_frame_0 = pd.read_csv(barcode_file, skipinitialspace=True)
barcode_frame_0.sort_values('total_counts', ascending=False, inplace=True)
barcode_frame_0.reset_index(drop=True, inplace=True)
if hist_bin_max is None:
hist_bin_max = barcode_frame_0[int(len(barcode_frame_0) /
50):int(len(barcode_frame_0) / 50) +
1]["total_counts"].values[0]
#Allow user to replot with different hist_bin_max
interact_hist = interact.options(manual=True,
manual_name="(re)plot histogram")
@interact_hist()
def plot_histogram(hist_max=str(hist_bin_max)):
#Plot histogram of Barcode counts to enable decision about threshold
plt.rcParams["figure.figsize"] = [16, 8]
fig, axs = plt.subplots(1, 2)
try:
hist_bin_max = float(hist_max)
bins = np.linspace(-0.5, hist_bin_max + 0.5, num_bins)
for ax in axs.flatten():
ax.hist(barcode_frame_0['total_counts'], bins=bins)
ax.set_xlabel('Barcode Count', size=20)
ax.set_ylabel('Number of Barcodes', size=20)
ax.tick_params(labelsize=16)
axs[0].hist(barcode_frame_0['total_counts'],
bins=bins,
histtype='step',
cumulative=-1)
axs[0].set_yscale('log')
axs[1].set_yscale('log')
axs[1].set_xlim(0, hist_bin_max / 3)
except:
print("hist_max needs to be a number")
if save_plots:
pdf.savefig()
if save_plots:
pdf.close()
return barcode_frame_0
def barplot(labels, data):
pos = np.arange(len(data))
plt.ion()
plt.xticks(pos + 0.4, labels)
plt.bar(pos, data)
plt.grid('on')
def total_plate_2_and_plot_bar_seq_quality(barcode_frame,
notebook_dir,
experiment=None,
show_plots=True,
save_plots=False,
cutoff=None,
num_to_plot=None,
export_trimmed_file=False,
trimmed_export_file=None):
# Turn interactive plotting on or off depending on show_plots
if show_plots:
plt.ion()
else:
plt.ioff()
if save_plots:
pdf_file = 'barcode quality plots.pdf'
pdf = PdfPages(pdf_file)
ref_seq_file = "reference_sequences.csv"
ref_seq_file_found = False
top_directory = notebook_dir
while not ref_seq_file_found:
find_result = top_directory.rfind("\\")
if find_result == -1:
break
else:
top_directory = top_directory[:find_result]
os.chdir(top_directory)
ref_seq_file_found = os.path.isfile(ref_seq_file)
if ref_seq_file_found:
ref_seq_frame = pd.read_csv(ref_seq_file, skipinitialspace=True)
else:
ref_seq_frame = None
data_directory = notebook_dir + "\\barcode_analysis"
os.chdir(data_directory)
if experiment is None:
experiment = get_exp_id(notebook_dir)
if cutoff is None:
hist_bin_max = barcode_frame[int(len(barcode_frame) /
50):int(len(barcode_frame) / 50) +
1]["total_counts"].values[0]
cutoff = int(hist_bin_max / 10)
print(f"Barcode frequency cutoff: {cutoff}")
#drop_list = list(barcode_frame[barcode_frame["total_counts"]<cutoff].index)
#barcode_frame.drop(drop_list, inplace=True)
barcode_frame = barcode_frame[
barcode_frame["total_counts"] > cutoff].copy()
barcode_frame.reset_index(drop=True, inplace=True)
if export_trimmed_file:
if trimmed_export_file is None:
trimmed_export_file = f"{experiment}.trimmed_sorted_counts.csv"
print(
f"Exporting trimmed barcode counts data to: {trimmed_export_file}")
barcode_frame.to_csv(trimmed_export_file)
for w in wells():
label = 'fraction_' + w
barcode_frame[label] = barcode_frame[w] / barcode_frame[w].sum()
barcode_frame['fraction_total'] = barcode_frame[
'total_counts'] / barcode_frame['total_counts'].sum()
plot_colors = sns.hls_palette(12, l=.4, s=.8)
plot_colors12 = []
for c in plot_colors:
for i in range(8):
plot_colors12.append(c)
BC_totals = []
index_list = []
for i, w in enumerate(wells()):
BC_totals.append(barcode_frame[w].sum())
index_list.append(i + 1)
BC_total_arr = []
for r in rows():
subarr = []
for c in columns():
subarr.append(barcode_frame[r + str(c)].sum())
BC_total_arr.append(subarr)
#Plot barcode read counts across plate
plt.rcParams["figure.figsize"] = [12, 16]
fig, axs = plt.subplots(2, 1)
r12 = np.asarray(np.split(np.asarray(BC_totals), 8)).transpose().flatten()
axs[0].scatter(index_list, r12, c=plot_colors12, s=70)
for i in range(13):
axs[0].plot([i * 8 + 0.5, i * 8 + 0.5],
[min(BC_totals), max(BC_totals)],
color='gray')
axs[0].set_title("Total Read Counts Per Sample", fontsize=32)
#axs[0].set_yscale('log');
axs[0].set_xlim(0, 97)
axs[0].set_xlabel('Sample Number', size=20)
axs[0].set_ylabel('Total Reads per Sample', size=20)
axs[0].tick_params(labelsize=16)
axs[1].matshow(BC_total_arr, cmap="inferno")
axs[1].grid(b=False)
axs[1].set_xticklabels([i + 1 for i in range(12)], size=16)
axs[1].set_xticks([i for i in range(12)])
axs[1].set_yticklabels([r + " " for r in rows()[::-1]], size=16)
axs[1].set_yticks([i for i in range(8)])
axs[1].set_ylim(-0.5, 7.5)
axs[1].tick_params(length=0)
if save_plots:
pdf.savefig()
if not show_plots:
plt.close(fig)
name_list = [""] * len(barcode_frame)
barcode_frame["RS_name"] = name_list
if ref_seq_frame is not None:
for index, row in ref_seq_frame.iterrows():
display_frame = barcode_frame[
barcode_frame["forward_BC"].str.contains(
row["forward_lin_tag"])]
display_frame = display_frame[
display_frame["reverse_BC"].str.contains(
row["reverse_lin_tag"])]
display_frame = display_frame[[
"RS_name", "forward_BC", "reverse_BC", "total_counts"
]]
if len(display_frame) > 0:
display_frame["RS_name"].iloc[0] = row["RS_name"]
barcode_frame.loc[display_frame.index[0],
"RS_name"] = row["RS_name"]
display(display_frame)
total_reads = barcode_frame["total_counts"].sum()
print(f"total reads: {total_reads}")
total_RS_reads = barcode_frame[
barcode_frame["RS_name"] != ""]["total_counts"].sum()
print(f"reference sequence reads: {total_RS_reads}")
total = []
for index, row in barcode_frame[wells_by_column()[:24]].iterrows():
counts = 0
for t in wells_by_column()[:24]:
counts += row[t]
total.append(counts)
barcode_frame['total_counts_plate_2'] = total
barcode_frame['fraction_total_p2'] = barcode_frame[
'total_counts_plate_2'] / barcode_frame['total_counts_plate_2'].sum()
#Plot Barcode fraction for each well in time point 1 vs. mean fraction in time point 1
plt.rcParams["figure.figsize"] = [16, 16]
fig, axs = plt.subplots(2, 2)
if num_to_plot is None:
f_data = barcode_frame
else:
f_data = barcode_frame[:num_to_plot]
f_x = f_data['fraction_total_p2']
for ax in axs.flatten()[:2]:
ax.plot([0, .125], [0, .125], color='k')
for ax in axs.flatten()[2:4]:
ax.plot([0, .125], [0, 0], color='k')
for i, w in enumerate(wells_by_column()[:24]):
c = [(plot_colors * 8)[i]] * len(f_data)
for ax in axs.flatten()[:2]:
ax.scatter(f_x, f_data['fraction_' + w], c=c)
for ax in axs.flatten()[2:4]:
ax.scatter(f_x, (f_data['fraction_' + w] - f_x) * 100, c=c)
axs.flatten()[1].set_xscale("log")
axs.flatten()[1].set_yscale("log")
axs.flatten()[1].set_xlim(0.01, 0.125)
axs.flatten()[1].set_ylim(0.01, 0.125)
axs.flatten()[3].set_xscale("log")
axs.flatten()[3].set_xlim(0.01, 0.125)
fig.suptitle('Fraction from Each Dual Barcode (Plate 2)',
fontsize=24,
position=(0.5, 0.905))
for ax in axs.flatten()[:2]:
ax.set_xlabel('Fraction Total', size=20)
ax.set_ylabel('Fraction per Sample', size=20)
ax.tick_params(labelsize=16)
for ax in axs.flatten()[2:4]:
ax.set_xlabel('Fraction Total', size=20)
ax.set_ylabel('Fraction per Sample - Fraction Total (%)', size=20)
ax.tick_params(labelsize=16)
if save_plots:
pdf.savefig()
if not show_plots:
plt.close(fig)
return barcode_frame
def piechart(labels, data):
plt.ion()
fig = plt.figure(figsize=(7, 7))
plt.pie(data, labels=labels, autopct='%1.2f%%')
plt.draw()
return fig
print("loading test_loader")
folder_test_input = folder2.ImageFolder(root=dir_test_input,
transform=transforms.ToTensor(),
loader=folder2.pil_loader)
test_loader_input = torch.utils.data.DataLoader(folder_test_input,
batch_size=2,
shuffle=False)
folder_test_output = folder2.ImageFolder(root=dir_test_output,
transform=transforms.ToTensor(),
loader=folder2.pil_loader)
test_loader_output = torch.utils.data.DataLoader(folder_test_output,
batch_size=2,
shuffle=False)
print("loading complete")
"""
# show image
f, a = plt.subplots(3, N_TEST_IMG, figsize=(5,3))
plt.ion()
for i in range(N_TEST_IMG):
a[0][i].imshow(view_data_in.data.cpu().numpy()[i].reshape(512, 350), cmap='gray')
a[0][i].set_xticks(())
a[0][i].set_yticks(())
a[1][i].imshow(view_data_out.data.cpu().numpy()[i].reshape(512, 350), cmap='gray')
a[1][i].set_xticks(())
a[1][i].set_yticks(())
"""
for epoch in range(EPOCH):
train_input_iter = iter(train_loader_input)
train_output_iter = iter(train_loader_output)
def output(vsd=0.1,
vb_low=0.0,
vb_high=80.0,
v_step=4,
step=100,
delay=100,
pair='0.5um'):
vsd = float(vsd)
vb_low = float(vb_low)
vb_high = float(vb_high)
# temp_A = lakeshore.ask('KRDG? A')
# T =float(temp_A.split('+')[1])
sd_sweep(start=0.0, end=-vsd, step=1000, delay=100)
bg_sweep(start=0.0, end=vb_low, step=4000, delay=100)
Range = 1.1 * (math.fabs(vsd))
source.write(':SOUR:VOLT:RANG ' + str(Range))
source.write(':SOUR:DEL ' + str(delay / 1000))
stage = 2 * vsd / step
v_stage = (vb_high - vb_low) / v_step
#real-time plotting
plt.ion()
for j in range(v_step + 1):
clear_data()
filename = time.strftime("%Y%m%d", time.localtime()) +'-'+'output'+'-'+'pair'+pair+'-'+'vsd'+'-'+str(vsd*1000)+'mV' \
+'-'+'vbg'+'-'+ str(vb_low+j*v_stage)+ 'V' + '-' + '20K'
if filename[-4:] != '.csv':
filename += '.csv'
#plt.figure(vb_low + j * v_stage)
for i in range(step + 1):
Vs = -vsd + stage * i
source.write(':source:volt %s' % Vs)
#source.write('read?')
data_bg = backgate.read("TRACE:DATA")
data_sd = source.read("TRACE:DATA")
# temp_A = lakeshore.ask('KRDG? A')
Ig = float(data_bg.split(',')[1]) * 1E9
Vg = float(vb_low + j * v_stage)
Is = float(data_sd.split(',')[1])
Vs = float(Vs)
Rs = math.fabs(Vs / Is)
# T = float(temp_A.split('+')[1])
Vg_list.append(Vg)
Ig_list.append(Ig)
Vsd_list.append(Vs)
Isd_list.append(Is)
Rsd_list.append(Rs)
#T_list.append(T)
plt.subplot(2, 2, 1)
plt.plot(Vs, Is, 'b.')
plt.xlabel('Vsd (V)')
plt.ylabel('Isd (A)')
plt.grid(True)
plt.subplot(2, 2, 2)
if Is > 0:
plt.semilogy(Vs, Is, 'b.')
plt.xlabel('Vsd (V)')
plt.ylabel('Isd (A)')
plt.grid(True)
plt.subplot(2, 2, 3)
plt.plot(Vs, Rs, 'b.')
plt.xlabel('Vsd (V)')
plt.ylabel('Rsd (Ohm)')
plt.grid(True)
plt.subplot(2, 2, 4)
plt.plot(Vs, Ig, 'r.')
plt.xlabel('Vsd (V)')
plt.ylabel('Ig (nA)')
plt.grid(True)
plt.tight_layout()
plt.pause(0.0001)
savefig(filename[:-4] + '.png')
plt.ioff()
csv_out = open(filename, 'wb')
mywriter = csv.writer(csv_out)
mywriter.writerow(('Vg', 'Ig(nA)', 'Vsd', 'Isd', 'Rsd'))
for row in zip(Vg_list, Ig_list, Vsd_list, Isd_list, Rsd_list):
mywriter.writerow(row)
csv_out.close()
if j != v_step:
bg_sweep(start=vb_low + j * v_stage,
end=vb_low + (j + 1) * v_stage,
step=4000,
delay=100)
sd_sweep(start=vsd, end=-vsd, step=1000, delay=100)
bg_sweep(start=vb_high, end=0.0, step=4000, delay=100)
sd_sweep(start=vsd, end=0.0, step=1000, delay=100)
def scatterplot(x, y):
plt.ion()
plt.plot(x, y, 'b.')
plt.xlim(min(x) - 1, max(x) + 1)
plt.ylim(min(y) - 1, max(y) + 1)
plt.draw()
def on_plot_salinity(self):
logger.debug("plot salinity")
with rc_context(self.rc_context):
plt.ion()
# figure and canvas
plt.close("Plot Salinity")
fig = plt.figure("Plot Salinity", figsize=self.f_sz, dpi=self.f_dpi)
fig.patch.set_alpha(0.0)
ax = fig.add_subplot(111)
ax.invert_yaxis()
y_min = None
y_max = None
x_min = None
x_max = None
# actually do the export
for pk in self._pks:
success = self.lib.load_profile(pk, skip_atlas=True)
if not success:
# noinspection PyCallByClass
QtGui.QMessageBox.warning(self, "Database", "Unable to load profile #%02d!" % pk, QtGui.QMessageBox.Ok)
continue
_x_min = self.lib.cur.proc.sal[self.lib.cur.proc_valid].min()
if x_min is None:
x_min = _x_min
else:
x_min = min(x_min, _x_min)
_x_max = self.lib.cur.proc.sal[self.lib.cur.proc_valid].max()
if x_max is None:
x_max = _x_max
else:
x_max = max(x_max, _x_max)
_y_min = self.lib.cur.proc.depth[self.lib.cur.proc_valid].min()
if y_min is None:
y_min = _y_min
else:
y_min = min(y_min, _y_min)
_y_max = self.lib.cur.proc.depth[self.lib.cur.proc_valid].max()
if y_max is None:
y_max = _y_max
else:
y_max = max(y_max, _y_max)
_, = ax.plot(
self.lib.cur.proc.sal[self.lib.cur.proc_valid],
self.lib.cur.proc.depth[self.lib.cur.proc_valid],
label='#%03d' % pk
)
logger.debug("x: min %.2f, max %.2f" % (x_min, x_max))
logger.debug("y: min %.2f, max %.2f" % (y_min, y_max))
x_range = x_max - x_min
y_range = y_max - y_min
ax.legend(loc='lower left')
plt.xlabel('Salinity [PSU]', fontsize=8)
plt.ylabel('Depth [m]', fontsize=8)
fig.get_axes()[0].set_xlim(x_min - 0.1*x_range, x_max + 0.1*x_range)
fig.get_axes()[0].set_ylim(y_max + 0.15*y_range, y_min - 0.05*y_range)
plt.grid()
plt.show()
self.accept()
def lockin_probe(vb_low=0.0, vb_high=80.0, step=100, delay=100):
vb_low = float(vb_low)
vb_high = float(vb_high)
filename = time.strftime("%Y%m%d", time.localtime(
)) + '-' + 'lockin-transfer' + '-' + 'sd-vxx' + '-' + 'vbg' + '-' + str(
vb_low) + '-' + str(vb_high) + 'V' + '-' + '100K'
if filename[-4:] != '.csv':
filename += '.csv'
bg_sweep(start=0.0, end=vb_low, step=1000, delay=100)
Range = 1.1 * (math.fabs(vb_high) if math.fabs(vb_high) > math.fabs(vb_low)
else math.fabs(vb_low))
backgate.write(':SOUR:VOLT:RANG ' + str(Range))
backgate.write(':SOUR:DEL ' + str(delay / 1000))
stage = (vb_high - vb_low) / step
clear_data()
#real-time plotting
plt.ion()
for i in range(step + 1):
Vg = vb_low + stage * i
backgate.write(':source:volt %s' % Vg)
# backgate.write('read?')
# data = inst.read(':CURR')
data_bg = backgate.read("TRACE:DATA")
temp_A = lakeshore.ask('KRDG? A')
T = float(temp_A.split('+')[1])
Ig = float(data_bg.split(',')[1])
Vg = round(Vg, 3)
X1 = math.fabs(float(lockin_1.ask('OUTP? 1')))
X1 = math.fabs(float(lockin_1.ask('OUTP? 1')))
Y1 = float(lockin_1.ask('OUTP? 2'))
Y1 = float(lockin_1.ask('OUTP? 2'))
R1 = float(lockin_1.ask('OUTP? 3'))
R1 = float(lockin_1.ask('OUTP? 3'))
theta1 = float(lockin_1.ask('OUTP? 4'))
theta1 = float(lockin_1.ask('OUTP? 4'))
X2 = math.fabs(float(lockin_2.ask('OUTP? 1')))
X2 = math.fabs(float(lockin_2.ask('OUTP? 1')))
Y2 = float(lockin_2.ask('OUTP? 2'))
Y2 = float(lockin_2.ask('OUTP? 2'))
R2 = float(lockin_2.ask('OUTP? 3'))
R2 = float(lockin_2.ask('OUTP? 3'))
theta2 = float(lockin_1.ask('OUTP? 4'))
theta2 = float(lockin_1.ask('OUTP? 4'))
X3 = math.fabs(float(lockin_3.ask('OUTP? 1')))
X3 = math.fabs(float(lockin_3.ask('OUTP? 1')))
Y3 = float(lockin_3.ask('OUTP? 2'))
Y3 = float(lockin_3.ask('OUTP? 2'))
R3 = float(lockin_3.ask('OUTP? 3'))
R3 = float(lockin_3.ask('OUTP? 3'))
theta3 = float(lockin_3.ask('OUTP? 4'))
theta3 = float(lockin_3.ask('OUTP? 4'))
R_2p = math.fabs(X1 / X3)
R_4p = math.fabs(X2 / X3)
Rc = (R_2p - R_4p * 1 / 1) / 2 # ohm
T_list.append(T)
Vg_list.append(Vg)
Ig_list.append(Ig)
X1_list.append(X1)
Y1_list.append(Y1)
R1_list.append(R1)
theta1_list.append(theta1)
X2_list.append(X2)
Y2_list.append(Y2)
R2_list.append(R2)
theta2_list.append(theta2)
X3_list.append(X3)
Y3_list.append(Y3)
R3_list.append(R3)
theta3_list.append(theta3)
R2p_list.append(R_2p)
R4p_list.append(R_4p)
Rc_list.append(Rc)
plt.subplot(2, 5, 1)
plt.plot(Vg_list, X1_list, r'b-D')
plt.xlabel('Vbg (V)')
plt.ylabel('V2p (V)')
plt.grid(True)
plt.subplot(2, 5, 3)
plt.plot(Vg_list, X3_list, r'b-D')
plt.xlabel('Vbg (V)')
plt.ylabel('Isd (A)')
plt.grid(True)
plt.subplot(2, 5, 2)
if R_2p > 0:
plt.semilogy(Vg_list, R2p_list, r'b-D')
plt.xlabel('Vbg (V)')
plt.ylabel('R2p (Ohm)')
plt.grid(True)
plt.subplot(2, 5, 4)
plt.plot(Vg_list, theta1_list, r'b-D')
plt.xlabel('Vbg (V)')
plt.ylabel('Theta_2p (degree)')
plt.grid(True)
plt.subplot(2, 5, 5)
plt.plot(Vg_list, Ig_list, r'b-D')
plt.xlabel('Vbg (V)')
plt.ylabel('Ig (A)')
plt.grid(True)
###################################
plt.subplot(2, 5, 6)
plt.plot(Vg_list, X2_list, r'b-D')
plt.xlabel('Vbg (V)')
plt.ylabel('V4p (V)')
plt.grid(True)
plt.subplot(2, 5, 8)
if Rc > 0:
plt.semilogy(Vg_list, Rc_list, r'b-D')
plt.xlabel('Vbg (V)')
plt.ylabel('Rc (ohm)')
plt.grid(True)
plt.subplot(2, 5, 7)
if R_4p > 0:
plt.semilogy(Vg_list, R4p_list, r'b-D')
plt.xlabel('Vbg (V)')
plt.ylabel('R4p (Ohm)')
plt.grid(True)
plt.subplot(2, 5, 9)
plt.plot(Vg_list, theta2_list, r'b-D')
plt.xlabel('Vbg (V)')
plt.ylabel('Theta_4p (degree)')
plt.grid(True)
plt.subplot(2, 5, 10)
plt.plot(Vg_list, T_list, r'b-D')
plt.xlabel('Vbg (V)')
plt.ylabel('T (K)')
plt.grid(True)
plt.tight_layout()
plt.pause(0.0001)
if i == step:
savefig(filename[:-4] + '.png')
plt.ioff()
#plt.close()
csv_out = open(filename, 'wb')
mywriter = csv.writer(csv_out)
mywriter.writerow(('Vg', 'V_2p', 'theta_2p', 'V_4p', 'theta_4p', 'R_2p',
'R_4p', 'Rc', 'Isd', 'Ig', 'T'))
for row in zip(Vg_list, X1_list, Y1_list, X2_list, Y2_list, R2p_list,
R4p_list, Rc_list, X3_list, Ig_list, T_list):
mywriter.writerow(row)
csv_out.close()
bg_sweep(start=vb_high, end=0.0, step=1000, delay=100)
from __future__ import print_function, division
import torch
import torch.nn as nn
import torch.optim as optim
from torch.optim import lr_scheduler
import numpy as np
import torchvision
from torchvision import datasets, models, transforms
import matplotlib.pyplot as plt
import time
import os
import copy
plt.ion() # interactive mode
# Data augmentation and normalization for training
# Just normalization for validation
data_transforms = {
'train':
transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
'val':
transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
plt.show()
axes = plt.gca()
axes.set_xlim(0, 100)
axes.set_ylim(-50, +50)
line, = axes.plot(xdata, ydata, 'ro')
for i in range(100):
xdata.append(i)
ydata.append(ysample[i])
#xdata = i
#ydata = ysample[i]
line.set_xdata(xdata)
line.set_ydata(ydata)
plt.draw()
plt.pause(1e-17)
time.sleep(0.01)
# add this if you don't want the window to disappear at the end
plt.show()
'''
plt.ion()
for i in range(10):
scat = plt.scatter(i, i)
plt.pause(0.5)
scat.remove()
'''
# 通过print可以直接打印网络的结构
# print(net) # net 的结构
# Net(
# (hidden): Linear(in_features=2, out_features=10, bias=True)
# (predict): Linear(in_features=10, out_features=2, bias=True)
# )
# optimizer 是训练的工具
optimizer = torch.optim.SGD(net.parameters(), lr=0.02)
# 传入 net 的所有参数, 学习率
loss_func = torch.nn.CrossEntropyLoss()
# 误差的计算方式，这里选用的交叉熵损失
# 交叉熵损失是分类中常用的一种损失函数，表示数据的不确定程度，大概可以这么理解，越合理的分类结果（视觉上就是成堆聚在一块的分成一类），其交叉熵值越小，反之，则越大
plt.ion() # 画图
plt.show()
for t in range(100):
res = net(x) # 喂给 net 训练数据 x, 输出分析值
# if t==90:
# print(res)
loss = loss_func(res, y) # 计算两者的误差
optimizer.zero_grad() # 清空上一步的残余更新参数值
loss.backward() # 误差反向传播, 计算参数更新值
optimizer.step() # 将参数更新值施加到 net 的 parameters 上
# 接着上面来
def __init__(self):
plt.ion()
def train_policy_gradient_agent(num_episodes, max_episode_length, batch_size,
learning_rate, gamma, regularisation, reward_to_exit=500, monitor=False,
showPlot=True):
# Initialise theta
theta = np.random.randn(1,4)
all_rewards = []
if showPlot:
plt.ion()
fig = plt.figure()
ax1 = fig.add_subplot(1,1,1)
velocity = np.zeros((1,4), dtype='float32')
last_avg_reward = 0
if monitor:
env.monitor.start('/tmp/cartpole-experiment-2')
for i_episode in range(num_episodes):
policy_gradients = []
policy_gradient = 0
batch_rewards = []
for i_batch in range(batch_size):
episode_rewards, episode_actions, episode_observations = run_episode(theta, max_episode_length)
batch_rewards.append(sum(episode_rewards))
# Now compute the policy gradient
batch_i_gradient = compute_policy_gradient(episode_rewards,
episode_actions, episode_observations, theta)
policy_gradients.append(batch_i_gradient)
mean_reward = np.mean(batch_rewards)
policy_gradient = 0
for i_batch in range(batch_size):
policy_gradients[i_batch] = policy_gradients[i_batch] / float(batch_rewards[i_batch]) * (batch_rewards[i_batch] - mean_reward)
policy_gradient = policy_gradient + 1.0 / batch_size * policy_gradients[i_batch]
# If we are above reward_to_exit for two episodes, then stop training
if (last_avg_reward > reward_to_exit) and (mean_reward >
reward_to_exit):
return theta
last_avg_reward = mean_reward
# Print the total reward for the episode
if i_episode % 50 == 0:
print('Reward', mean_reward, ', episode:', i_episode)
if showPlot:
all_rewards.append(mean_reward)
ax1.clear()
ax1.plot(all_rewards)
plt.pause(0.0001)
# Apply regularisation
policy_gradient = policy_gradient - regularisation * sum(theta*theta)
alpha = 30*learning_rate / (30 + i_episode)
velocity = gamma * velocity + alpha * policy_gradient
theta = theta + velocity
if monitor:
env.monitor.close()
plt.show()
# Finally, return the theta we find
return theta
def socket_csi():
"""
parameter:
-channel 6
-BW 20
-package len 274
-[0 1 2 3 ] magic bytes 0x11111111 4
-[4 5 6 7 8 9 ] source mac addr 6
-[10 11 ] sequence number 2
-[12 13 ] <core and spatial number> 2
-[14 15 ] chanspec channel/BW 2
-[16 17 ] chip version 2
-[18 274 ] real data 256
"""
#1 0100 0000 0001 0001 1000 0001 0011
#10100 11000 10011
udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
udp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
udp_socket.bind(("", 5500))
global count
count = 0
print('[===============START===============]')
# plt interactive
plt.ion()
# plt.rcParams['figure.figsize'] = (10, 10)
# plt.rcParams['font.sans-serif'] = ['SimHei']
# plt.rcParams['axes.unicode_mius'] = False
# plt.rcParams['lines.linewidth'] = 1
global compare_list
compare_list = []
global var_list_7
var_list_7 = []
global var_list_5
var_list_5 = []
global var_list_3
var_list_3 = []
global var_list_2
var_list_2 = []
compare_value = np.arange(100)
global fig
global ax
fig, ax = plt.subplots()
while 1:
data, addr = udp_socket.recvfrom(1024)
np_data = np.frombuffer(data, dtype=np.int16, offset=18)
# print("np_data",np_data)
print('-----------------')
magic_bytes = []
source_mac = []
sequence_number = []
core_spatial_number = []
chan_spec = []
chip_version = []
real_data = []
if len(data) != 274:
continue
# magic_bytes = [x for x in data[:4]]
# print("magic_bytes:", magic_bytes, [hex(x) for x in magic_bytes])
# source_mac = [x for x in data[4:10]]
# print("source_mac:",source_mac,[hex(x) for x in source_mac])
# sequence_number = [x for x in data[10:12]]
# print("sequence_number:",sequence_number, [hex(x) for x in sequence_number])
# core_spatial_number = [x for x in data[12:14]]
# print("core_spatial_number:",core_spatial_number)
# chanspec = [x for x in data[14:16]]
# print("chanspec:",chanspec)
# chip_version = [x for x in data[16:18]]
# print("chip_version",chip_version)
# real_data = [x for x in data[18:]]
# print("real_data:",real_data,len(real_data))
count += 1
# if count >= 200:
# break
treat_one_package(np_data, count)
#control package number
udp_socket.close()
plt.ioff()
plt.show()
Box(Point3D(-50, -50, 50), Point3D(50, 50, 50.1), world, material=Checkerboard(4, d65_white, d65_white, 0.001, 0.002))
# Box(Point(-100, -100, -100), Point(100, 100, 100), world, material=UniformSurfaceEmitter(d65_white, 0.001))
# OBSERVER --------------------------------------------------------------------
#import cProfile
#
# def profile_test(n=25000):
# r = Ray(origin=Point(0.0, 0, 0), min_wavelength=526, max_wavelength=532, num_samples=100)
# for i in range(n):
# r.trace(world)
#
# cProfile.run("profile_test()", sort="tottime")
ion()
r = Ray(origin=Point3D(0.5, 0, -2.5), min_wavelength=440, max_wavelength=740, bins=800)
s = r.trace(world)
plot(s.wavelengths, s.samples)
r = Ray(origin=Point3D(0.5, 0, -2.5), min_wavelength=440, max_wavelength=740, bins=1600)
s = r.trace(world)
plot(s.wavelengths, s.samples)
show()
camera = PinholeCamera((128, 128), parent=world, transform=translate(0, 0, -2.5))
camera.spectral_rays = 1
camera.spectral_bins = 21
camera.pixel_samples = 50
def train(self):
### Inicializando os pesos
self.A = np.random.rand(self.Ns, self.Nh) * self.Aini
### Inicializando os centros
self.t = np.zeros((1, self.Nh))
idx = np.random.permutation(self.Nh)
for j in xrange(self.Nh):
self.t[0,j] = self.d[idx[j]]
### Inicializando as larguras
self.R = abs(np.max(self.t) - np.min(self.t)) / 2
self.tat = np.ones(self.t.shape) * self.delta0
self.taA = np.ones(self.A.shape) * self.delta0
grt_ant = grR_ant = grA_ant = 0
MSE = np.zeros(self.epoch_max)
plt.ion()
for epoca in xrange(self.epoch_max):
z = np.zeros(self.N)
E = np.zeros(self.N)
deltat = np.ones(self.t.shape)
deltaA = np.ones(self.A.shape)
gradt = gradR = gradA = 0
index = np.random.permutation(self.N)
for i in index:
xi = self.X_train[i]#np.array([self.X_train[i]]).reshape(1, -1)
theta = (xi - self.t) / self.R
yj = self.sig_dev2(theta)
z[i] = np.dot(self.A, yj.T)[0][0]
e = self.d[i] - z[i]
#self.A = self.A + (self.eta * e * yj)
#self.t = self.t - (self.eta * e * self.A / self.R * self.sig_dev3(theta))
#self.R = self.R - (((self.eta * e * self.A * (xi - self.t)) / self.R**2) * self.sig_dev3(theta))
gradA += (-e * yj)
gradt += (e * self.A / self.R * self.sig_dev3(theta))
self.R = self.R - (self.delta0 * (e * self.A * (xi - self.t)) / self.R**2) * self.sig_dev3(theta)
#self.R -= (self.delta0 * gradR)
E[i] = 0.5 * e**2
grt = np.sign(gradt)
grA = np.sign(gradA)
if epoca == 0:
self.t += (-self.delta0 * gradt)
self.R += (-self.delta0 * gradR)
self.A += (-self.delta0 * gradA)
else:
Dt = grt * grt_ant
DA = grA * grA_ant
sizet = Dt.shape
sizeA = DA.shape
for i in xrange(sizet[0]):
for j in xrange(sizet[1]):
if (Dt[i,j] > 0):
self.tat[i,j] = min(self.tat[i,j] * self.eta_plus, self.delta_max)
elif (Dt[i,j] < 0):
self.tat[i,j] = max(self.tat[i,j] * self.eta_less, self.delta_min)
if (grt[i,j] > 0):
deltat[i,j] = -self.tat[i,j]
elif (grt[i,j] < 0):
deltat[i,j] = self.tat[i,j]
for i in xrange(sizeA[0]):
for j in xrange(sizeA[1]):
if (DA[i,j] > 0):
self.taA[i,j] = min(self.taA[i,j] * self.eta_plus, self.delta_max)
elif (DA[i,j] < 0):
self.taA[i,j] = max(self.taA[i,j] * self.eta_less, self.delta_min)
if (grA[i,j] > 0):
deltaA[i,j] = -self.taA[i,j]
elif (grA[i,j] < 0):
deltaA[i,j] = self.taA[i,j]
self.t += deltat
self.A += deltaA
grt_ant = grt
grA_ant = grA
MSE[epoca] = np.sum(E) / self.N
if (epoca % 200 == 0 or epoca == self.epoch_max - 1):
if (epoca != 0):
plt.cla()
plt.clf()
self.plot(z, epoca)
print MSE[-1]
return MSE
def plot(st, inv=None, event=None, zoom=1, yinfo=False, stationlabel=True, epidistances=None, markphases=None, phaselabel=True, phaselabelclr='red',
norm=False, clr=None, clrtrace=None, newfigure=True, savefig=False, dpi=400, xlabel=None, ylabel=None, yticks=False, t_axis=None,
fs=15, tw=None, time_shift=None, verbose=False, kind='classic', labelfs=20, ylimit=None):
"""
Alpha Version!
Needs inventory and event of catalog for yinfo using
param st: stream
type st: obspy.core.stream.Stream
param inv: inventory
type inv:
param event: event of the seismogram
type event:
param zoom: zoom factor of the traces
type zoom: float
param yinfo: Plotting with y info as distance of traces
type yinfo: bool
param markphases: Phases, that should be marked in the plot, default is "None"
type markphases: list
param norm: Depiction of traces; unprocessed or normalized. Normalization options are:
all - normalized on biggest value of all traces
trace - each trace is normalized on its biggest value
type norm: string or bool
param clr: Color of plot
type clr: string
param clrtrace: dict containing tracenumber and color, e.g.:
>>> clrtrace = {1: 'red', 7: 'green'}
>>> trace 1 in red
>>> trace 7 in green
or
attribute a trace, so only traces with that attribute are plot in red, e.g.:
clrtrace='pocs', clrtrace='empty'
type clrtrace: list
"""
#check for Data input
if not isinstance(st, Stream):
if not isinstance(st, Trace):
try:
if isinstance(yinfo,bool):
yinfo = 1
plot_data(st, zoom=zoom, y_dist=yinfo, clr=clr, newfigure=newfigure, savefig=savefig, dpi=dpi, xlabel=xlabel, ylabel=ylabel, t_axis=t_axis, fs=fs)
return
except:
msg = "Wrong data input, must be Stream or Trace"
raise TypeError(msg)
if newfigure:
# Set axis information and bools.
fig, ax = plt.subplots()
if xlabel:
ax.set_xlabel(xlabel, fontsize=fs)
else:
ax.set_xlabel("Time(s)", fontsize=fs)
if ylabel:
ax.set_ylabel(ylabel, fontsize=fs)
ax.tick_params(axis='both', which='major', labelsize=fs)
clr = 'black'
cclr = 'black'
else:
ax = plt.gca()
fig = plt.gcf()
if not clr:
clr = 'blue'
cclr = 'blue'
if isinstance(st, Stream):
# Check if just specific timewindow should be plotted.
try:
tw = np.array(tw)
twdelta = tw.max() - tw.min()
t_axis = np.linspace(tw.min(),tw.max(), twdelta/float(st[0].stats.delta))
npts_min = int(tw.min()/float(st[0].stats.delta))
npts_max = int(tw.max()/float(st[0].stats.delta))
except:
t_axis_max = st[0].stats.delta * st[0].stats.npts
t_axis = np.linspace(0,t_axis_max, st[0].stats.npts)
tw = np.array([0, t_axis_max])
npts_min = 0
npts_max = st[0].stats.npts
data = stream2array(st)
if time_shift:
data = np.roll(data, time_shift*int(st[0].stats.sampling_rate))
spacing=2.
ax.set_xlim(tw.min(), tw.max())
isinv = False
isevent = False
# Check if inventory and catalog is input, then calculate distances etc.
if isinstance(inv, Inventory): isinv = True
if isinstance(event,Event): isevent = True
if isinv:
# Calculates y-axis info using epidistance information of the stream.
# Check if there is a network entry
attach_network_to_traces(st,inv)
attach_coordinates_to_traces(st, inv, event)
else:
for trace in st:
try:
if not trace.stats.distance:
isinv = False
break
else:
isinv = True
except:
isinv = False
break
try:
depth = event.origins[0]['depth']/1000.
isevent = True
except AttributeError:
try:
depth = st[0].stats.depth
isevent = True
except AttributeError:
isevent = False
yold=0
# Normalize Data, if set to 'all'
if norm in ['all']:
data = data/data.max()
if yinfo:
ymin = st[0].stats.distance
ymax = st[0].stats.distance
if markphases and isinv and isevent:
try:
origin = event.origins[0]['time']
depth = event.origins[0]['depth']/1000.
except:
origin = st[0].stats.origin
depth = st[0].stats.depth
m = TauPyModel('ak135')
if kind in ('classic', 'Classic'):
for j, trace in enumerate(data):
# Normalize trace, if set to 'trace'
if norm in ['trace']:
trace = trace/trace.max()
try:
y_dist = st[j].stats.distance
except:
y_dist = yold + 1
if markphases and isinv and isevent:
arrivals = m.get_travel_times(depth, y_dist, phase_list=markphases)
timetable = [ [], [] ]
for k, phase in enumerate(arrivals):
phase_name = phase.name
t = phase.time
phase_time = origin + t - st[j].stats.starttime
Phase_npt = int(phase_time/st[j].stats.delta)
Phase = Phase_npt * st[j].stats.delta
if Phase < t_axis.min() or Phase > t_axis.max():
continue
else:
timetable[0].append(phase_name)
timetable[1].append(Phase)
if not timetable[0] or not timetable[1]:
print('Phases not in Seismogram')
plt.close('all')
return
if yinfo:
if not ylabel: ax.set_ylabel("Distance(deg)", fontsize=fs)
if st[j].stats.distance < ymin: ymin = st[j].stats.distance
if st[j].stats.distance > ymax: ymax = st[j].stats.distance
try:
if j in clrtrace:
cclr = clrtrace[j]
else:
cclr = clr
except TypeError:
if clrtrace in st[j].stats:
cclr = 'red'
else:
cclr = clr
except:
cclr = clr
if stationlabel:
ax.annotate('%s' % st[j].stats.station, xy=(1 + tw.min(),y_dist+0.1))
ax.plot(t_axis,zoom*trace[npts_min: npts_max]+ y_dist, color=cclr)
ax.plot( (timetable[1],timetable[1]),(-1+y_dist,1+y_dist), color=phaselabelclr )
if verbose:
print(timetable[1] + st[j].stats.shifttime)
ax.plot( (timetable[1] + st[j].stats.shifttime, timetable[1] + st[j].stats.shifttime), \
(-1+y_dist,1+y_dist), color=phaselabelclr )
if phaselabel:
for time, key in enumerate(timetable[0]):
ax.annotate('%s' % key, xy=(timetable[1][time],y_dist))
if verbose:
ax.annotate('%s' % key, xy=(timetable[1][time] + st[j].stats.shifttime, y_dist))
else:
continue
else:
if not ylabel: ax.set_ylabel("No. of trace", fontsize=fs)
try:
if j in clrtrace:
cclr = clrtrace[j]
else:
cclr = clr
except TypeError:
if clrtrace in st[j].stats:
cclr = 'red'
else:
cclr = clr
except:
cclr = clr
fig.gca().yaxis.set_major_locator(plt.NullLocator())
if stationlabel:
ax.annotate('%s' % st[j].stats.station, xy=(1 + tw.min(),spacing*j+0.1))
ax.plot(t_axis,zoom*trace[npts_min: npts_max]+ spacing*j, color=cclr)
ax.plot( (timetable[1],timetable[1]),(-1+spacing*j,1+spacing*j), color=phaselabelclr )
if verbose:
print(st[j].stats.shifttime)
print(timetable[1] + st[j].stats.shifttime)
ax.plot( (timetable[1] + st[j].stats.shifttime, timetable[1] + st[j].stats.shifttime), \
(-1+spacing*j,1+spacing*j), color=phaselabelclr )
if phaselabel:
for time, key in enumerate(timetable[0]):
ax.annotate('%s' % key, xy=(timetable[1][time],spacing*j))
if verbose:
ax.annotate('%s' % key, xy=(timetable[1][time] + st[j].stats.shifttime, spacing*j))
else:
continue
elif markphases and not isinv:
msg='markphases needs Inventory Information, not found.'
raise IOError(msg)
elif markphases and not isevent:
msg='markphases needs Event Information, not found.'
raise IOError(msg)
elif type(epidistances) == numpy.ndarray or type(epidistances)==list:
y_dist = epidistances
if not ylabel: ax.set_ylabel("Distance(deg)", fontsize=fs)
try:
if j in clrtrace:
cclr = clrtrace[j]
else:
cclr = clr
except:
cclr = clr
if stationlabel:
ax.annotate('%s' % st[j].stats.station, xy=(1 + tw.min(),y_dist[j]+0.1))
ax.plot(t_axis, zoom*trace[npts_min: npts_max] + y_dist[j], color=cclr)
else:
if yinfo:
try:
if not ylabel: ax.set_ylabel("Distance(deg)", fontsize=fs)
try:
if j in clrtrace:
cclr = clrtrace[j]
else:
cclr = clr
except TypeError:
if clrtrace in st[j].stats:
cclr = 'red'
else:
cclr = clr
except:
cclr = clr
except:
msg='Oops, something not found.'
raise IOError(msg)
if st[j].stats.distance < ymin: ymin = st[j].stats.distance
if st[j].stats.distance > ymax: ymax = st[j].stats.distance
if stationlabel:
ax.annotate('%s' % st[j].stats.station, xy=(1 + tw.min(),y_dist+0.1))
ax.plot(t_axis,zoom*trace[npts_min: npts_max]+ y_dist, color=cclr)
else:
if not ylabel: ax.set_ylabel("No. of trace", fontsize=fs)
try:
if j in clrtrace:
cclr = clrtrace[j]
else:
cclr = clr
except:
cclr = clr
if stationlabel:
ax.annotate('%s' % st[j].stats.station, xy=(1 + tw.min(),spacing*j+0.1))
ax.plot(t_axis,zoom*trace[npts_min: npts_max]+ spacing*j, color=cclr)
yold = y_dist
if not yticks:
fig.gca().yaxis.set_major_locator(plt.NullLocator())
elif kind in ['contour', 'Contour']:
yrange = np.arange(len(st))
try:
cax = ax.imshow(zoom*data[tw.min():tw.max()], aspect='auto', extent=(tw.min(), tw.max(), yrange.min(), yrange.max()),
origin='lower', cmap='seismic')
except:
cax = ax.imshow(zoom*data, aspect='auto', extent=(t_axis.min(), t_axis.max(), yrange.min(), yrange.max()),
origin='lower', cmap='seismic')
if markphases and isinv and isevent:
stats = np.arange(len(st))
for j in stats:
arrivals = m.get_travel_times(depth, st[j].stats.distance, phase_list=markphases)
timetable = [ [], [] ]
for phase in arrivals:
t = phase.time
phase_time = origin + t - st[j].stats.starttime
Phase_npt = int(phase_time / st[j].stats.delta)
tPhase = Phase_npt * st[j].stats.delta
name = phase.name
if tPhase > t_axis.max() or tPhase < t_axis.min():
continue
ax.autoscale(False)
ax.plot( (tPhase, tPhase), (-labelfs/100. +j, labelfs/100.+j), color='red')
if j == stats.max():
if name in [u'P^220P']:
ax.annotate('$P^{220}P$', xy=(tPhase, j), xytext=(tPhase + 1, j+1.2),
fontsize=labelfs, color='black')
elif name in [u'P^410P']:
ax.annotate('$P^{410}P$', xy=(tPhase, j), xytext=(tPhase + 1, j+1.2),
fontsize=labelfs, color='black')
elif name in [u'P^660P']:
ax.annotate('$P^{660}P$', xy=(tPhase, j), xytext=(tPhase + 1, j+1.2),
fontsize=labelfs, color='black')
else:
ax.annotate('$%s$' % name, xy=(tPhase, j), xytext=(tPhase + 1, j+1.2),
fontsize=labelfs, color='black')
cbar = fig.colorbar(cax, format='%.1f')
cbar.set_clim(-1, 1)
cbar.ax.tick_params(labelsize=fs)
cbar.ax.set_ylabel('A', fontsize=fs)
if yinfo:
ylim = (ymin-1, ymax+1)
ax.set_ylim(ylim)
if savefig:
fig.set_size_inches(8, 7)
fig.savefig(savefig, dpi=dpi)
plt.close("all")
else:
plt.ion()
plt.draw()
plt.show()
plt.ioff()
elif isinstance(st, Trace):
t_axis = np.linspace(0, st.stats.delta * st.stats.npts, st.stats.npts)
data = st.data.copy()
if norm in ['all', 'All', 'trace', 'Trace']:
data = data/data.max()
try:
y_dist = st.stats.distance
except:
print("No distance information attached to trace, no phases are calculated!")
markphases=False
if ylimit:
ax.set_ylim(ylimit)
if markphases:
try:
origin = event.origins[0]['time']
depth = event.origins[0]['depth']/1000.
except:
origin = st.stats.origin
depth = st.stats.depth
m = TauPyModel('ak135')
arrivals = m.get_travel_times(depth, y_dist, phase_list=markphases)
timetable = [ [], [] ]
for k, phase in enumerate(arrivals):
phase_name = phase.name
t = phase.time
phase_time = origin + t - st.stats.starttime
Phase_npt = int(phase_time/st.stats.delta)
Phase = Phase_npt * st.stats.delta
if Phase < t_axis.min() or Phase > t_axis.max():
continue
else:
timetable[0].append(phase_name)
timetable[1].append(Phase)
if not ylabel: ax.set_ylabel("Amplitude", fontsize=fs)
title = st.stats.network+'.'+st.stats.station+'.'+st.stats.location+'.'+st.stats.channel
ax.set_title(title, fontsize=fs)
#plt.gca().yaxis.set_major_locator(plt.NullLocator())
ax.plot(t_axis,zoom*data, color=clr)
ax.plot( (timetable[1],timetable[1]),(-0.5,0.5), color=phaselabelclr )
if phaselabel:
for time, key in enumerate(timetable[0]):
ax.annotate('%s' % key, xy=(timetable[1][time]+5,0.55))
else:
if not ylabel: ax.set_ylabel("Amplitude", fontsize=fs)
title = st.stats.network+'.'+st.stats.station+'.'+st.stats.location+'.'+st.stats.channel
ax.set_title(title, fontsize=fs)
ax.plot(t_axis, zoom*data, color=clr)
if savefig:
plt.savefig(savefig)
plt.close("all")
else:
plt.ion()
plt.draw()
plt.show()
plt.ioff()
def chanvese(I,
init_mask,
max_its=200,
alpha=0.2,
thresh=0,
color='r',
display=False):
I = I.astype(np.float)
# Create a signed distance map (SDF) from mask
phi = mask2phi(init_mask)
if display:
plt.ion()
fig, axes = plt.subplots(ncols=2)
show_curve_and_phi(fig, I, phi, color)
plt.savefig('levelset_start.png', bbox_inches='tight')
# Main loop
its = 0
stop = False
prev_mask = init_mask
c = 0
while (its < max_its and not stop):
# Get the curve's narrow band
idx = np.flatnonzero(np.logical_and(phi <= 1.2, phi >= -1.2))
if len(idx) > 0:
# Intermediate output
if display:
if np.mod(its, 50) == 0:
print('iteration: {0}'.format(its))
show_curve_and_phi(fig, I, phi, color)
else:
pass
#if np.mod(its, 10) == 0:
#print('iteration: {0}'.format(its))
# Find interior and exterior mean
upts = np.flatnonzero(phi <= 0) # interior points
vpts = np.flatnonzero(phi > 0) # exterior points
u = np.sum(I.flat[upts]) / (len(upts) + eps) # interior mean
v = np.sum(I.flat[vpts]) / (len(vpts) + eps) # exterior mean
# Force from image information
#F = (I.flat[idx] - u)**2 - (I.flat[idx] - v)**2
partial_seg = phi <= 0
F = 2 * (I - partial_seg.astype(np.float64)).flat[idx]
# Force from curvature penalty
curvature = get_curvature(phi, idx)
# Gradient descent to minimize energy
dphidt = F / np.max(np.abs(F)) + alpha * curvature
# Maintain the CFL condition
dt = 0.45 / (np.max(np.abs(dphidt)) + eps)
# Evolve the curve
phi.flat[idx] += dt * dphidt
# Keep SDF smooth
phi = sussman(phi, 0.5)
new_mask = phi <= 0
c = convergence(prev_mask, new_mask, thresh, c)
if c <= 5:
its = its + 1
prev_mask = new_mask
else:
stop = True
else:
break
# Final output
if display:
show_curve_and_phi(fig, I, phi, color)
plt.savefig('levelset_end.png', bbox_inches='tight')
# Make mask from SDF
seg = phi <= 0 # Get mask from levelset
return seg, phi, its
def dcg_solver(A, b, mu,niter,x0=None):
"""
Damped conjugate gradient solver for Ax = b lstsqs problems, as shown in Tomographic
inversion via the conjugate gradient method, Scales, J. 1987
Expect a mxn Matrix A, a rhs b and an optional startvalue x0
minimizes the following problem by applying CGLS to:
|| ( A ) ( b ) ||^{2}
min || (mu * I) *x - ( 0 ) ||_{2}
==> min || G * m - d || ^{2}_{2}
"""
print("--- Using dCG-method --- \n \nInitiating matrices... \n \n")
# Create G matrix and d Vector.
I = mu**2. * sparse.identity(A.shape[0])
G = sparse.lil_matrix(np.vstack((A.toarray(), I.toarray())))
G = G.tocsc()
d = np.hstack( (b, np.zeros(I.shape[0])) )
# Initialize startvalues.
try:
if not x0:
m = np.zeros(A.shape[1])
s = -d
except ValueError:
if x0.any():
m = x0
s = G.dot(m) - d
except:
msg = 'No valid input'
raise IOError(msg)
beta_old = 0.
r = G.transpose().conjugate().dot(s)
p_old = np.zeros(r.shape)
print("Starting iterations. \n \n")
cont = True
k = 1
while cont:
p = -r + beta_old * p_old
alpha = np.linalg.norm(r,2)**2. / p.dot(G.transpose().conjugate().toarray()).dot(G.dot(p))
m_new = m + alpha * p
s_new = s + alpha * G.dot(p)
r_new = G.transpose().conjugate().dot(s_new)
beta = np.linalg.norm(r_new,2)**2. / np.linalg.norm(r,2)**2.
m = m_new.copy()
s = s_new.copy()
r = r_new.copy()
beta_old = beta.copy()
p_old = p.copy()
misfit = np.linalg.norm(G.dot(m) - d, 2)
rnorm = np.linalg.norm(m,2)**2.
plt.ion()
plt.figure()
plt.imshow(abs(m.reshape(20,300)),aspect='auto', interpolation='none')
plt.show()
if k == niter: cont=False
k +=1
x = m.copy()
return x
nn.Linear(128, 28 * 28),
nn.Sigmoid(),
)
def forward(self, x):
encoded = self.encoder(x)
decoded = self.decoder(encoded)
return encoded, decoded
autoencoder = AutoEncoder()
optimizer = torch.optim.Adam(autoencoder.parameters(), lr=LR)
loss_func = nn.MSELoss()
f, a = plt.subplots(2, N_TEST_IMG, figsize=(5, 2))
plt.ion() # continuously plot
# original data (first row) for viewing
view_data = train_data.train_data[:N_TEST_IMG].view(-1, 28 * 28).type(
torch.FloatTensor) / 255.
for i in range(N_TEST_IMG):
a[0][i].imshow(np.reshape(view_data.data.numpy()[i], (28, 28)),
cmap='gray')
a[0][i].set_xticks(())
a[0][i].set_yticks(())
for epoch in range(EPOCH):
for step, (x, b_label) in enumerate(train_loader):
b_x = x.view(-1, 28 * 28) # batch x, shape (batch, 28*28)
b_y = x.view(-1, 28 * 28) # batch y, shape (batch, 28*28)
