def display_wav(filename):
input_data = read(filename)
audio_in = input_data[1]
samples = len(audio_in)
fig = pylab.figure();
print samples/44100.0," seconds"
k = 0
plot_data_out = []
for i in xrange(samples):
plot_data_out.append(audio_in[k]/32768.0)
k = k+1
pdata = numpy.array(plot_data_out, dtype=numpy.float)
pylab.plot(pdata)
pylab.grid(True)
pylab.ion()
pylab.show()
python类ion()的实例源码
def plot_profiles(self):
"""
Plot TOPP profiles, e.g. for debugging.
"""
import pylab
pylab.ion()
self.topp.WriteProfilesList()
self.topp.WriteSwitchPointsList()
profileslist = TOPP.TOPPpy.ProfilesFromString(
self.topp.resprofilesliststring)
switchpointslist = TOPP.TOPPpy.SwitchPointsFromString(
self.topp.switchpointsliststring)
TOPP.TOPPpy.PlotProfiles(profileslist, switchpointslist)
TOPP.TOPPpy.PlotAlphaBeta(self.topp)
pylab.title("%s phase profile" % type(self).__name__)
pylab.axis([0, 1, 0, 10])
def draw_loop():
"""
Draw the graph in a loop
"""
global G
plt.ion()
# mng = plt.get_current_fig_manager()
# mng.resize(*mng.window.maxsize())
plt.draw()
for line in fileinput.input():
if output(line):
plt.clf()
nx.draw(G)
plt.draw()
def _plot(self):
# Called from the main thread
pylab.ion()
if not getattr(self, 'data_available', False):
return
if self.peaks is not None:
for key in self.sign_peaks:
for channel in self.peaks[key].keys():
self.rates[key][int(channel)] += len(self.peaks[key][channel])
pylab.scatter(self.positions[0, :], self.positions[1, :], c=self.rates[key])
pylab.gca().set_title('Buffer %d' %self.counter)
pylab.draw()
return
def visualiseNormObject(self):
shape = (2*self.extent, 2*self.extent)
pylab.ion()
pylab.clf()
#pylab.set_cmap("bone")
pylab.hot()
pylab.title("image: %s" % self.fitsFile)
pylab.imshow(np.reshape(self.signPreserveNorm(), shape, order="F"), interpolation="nearest")
pylab.plot(np.arange(0,2*self.extent), self.extent*np.ones((2*self.extent,)), "r--")
pylab.plot(self.extent*np.ones((2*self.extent,)), np.arange(0,2*self.extent), "r--")
pylab.colorbar()
pylab.ylim(-1, 2*self.extent)
pylab.xlim(-1, 2*self.extent)
pylab.xlabel("Pixels")
pylab.ylabel("Pixels")
pylab.show()
def visualiseNormObject(self):
shape = (2*self.extent, 2*self.extent)
pylab.ion()
pylab.clf()
#pylab.set_cmap("bone")
pylab.hot()
pylab.title("image: %s" % self.fitsFile)
pylab.imshow(np.reshape(self.signPreserveNorm(), shape, order="F"), interpolation="nearest")
pylab.plot(np.arange(0,2*self.extent), self.extent*np.ones((2*self.extent,)), "r--")
pylab.plot(self.extent*np.ones((2*self.extent,)), np.arange(0,2*self.extent), "r--")
pylab.colorbar()
pylab.ylim(-1, 2*self.extent)
pylab.xlim(-1, 2*self.extent)
pylab.xlabel("Pixels")
pylab.ylabel("Pixels")
pylab.show()
def data_loop(self):
import pylab
fig = pylab.figure()
pylab.ion()
while True:
fig.clear()
#pylab.plot(self.t[np.where(self.on==0)])
hz = 1000000 / self.delta
pylab.hist(hz, 50, range=(800, 1200))
pylab.xlim(500, 1500)
pylab.ylim(0, 100)
self.delta = self.delta[:0]
fig.canvas.draw()
fig.canvas.flush_events()
def __init__(self):
pylab.ion()
self.com_real = []
self.com_ref = []
self.support_areas = []
self.xlabel = "$y$ (m)"
self.ylabel = "$x$ (m)"
self.xlim = (-0.6, 0.1)
self.ylim = (0. - 0.05, 1.4 + 0.05)
self.zmp_real = []
self.zmp_ref = []
def test_discretization(nmpc, nb_steps):
dT = nmpc.preview.dT
pylab.ion()
pylab.clf()
ax = pylab.subplot(311)
ax.set_color_cycle(['r', 'g', 'b'])
pylab.plot(
[sum(dT[:i]) for i in xrange(len(dT))],
nmpc.preview.P, marker='o')
pylab.plot(
pylab.linspace(0., sum(dT), nb_steps + 1),
[x[0:3] for x in nmpc.preview.discretize(nb_steps)],
marker='s', linestyle='--')
ax = pylab.subplot(312)
ax.set_color_cycle(['r', 'g', 'b'])
pylab.plot(
[sum(dT[:i]) for i in xrange(len(dT))],
nmpc.preview.V, marker='o')
pylab.plot(
pylab.linspace(0., sum(dT), nb_steps + 1),
[x[3:6] for x in nmpc.preview.discretize(nb_steps)],
marker='s', linestyle='--')
ax = pylab.subplot(313)
ax.set_color_cycle(['r', 'g', 'b'])
pylab.plot(
[sum(dT[:i]) for i in xrange(len(dT))],
nmpc.preview.Z, marker='o')
pylab.plot(
pylab.linspace(0., sum(dT), nb_steps + 1),
[x[6:9] for x in nmpc.preview.discretize(nb_steps)],
marker='s', linestyle='--')
def test_dT_impact(xvals, f, nmpc, sim, start=0.1, end=0.8, step=0.02, ymax=200,
sample_size=100, label=None):
"""Used to generate Figure XX of the paper."""
c = raw_input("Did you remove iter/time caps in IPOPT settings? [y/N] ")
if c.lower() not in ['y', 'yes']:
print "Then go ahead and do it."
return
stats = [Statistics() for _ in xrange(len(xvals))]
fails = [0. for _ in xrange(len(xvals))]
pylab.ion()
pylab.clf()
for (i, dT) in enumerate(xvals):
f(dT)
for _ in xrange(sample_size):
nmpc.on_tick(sim)
if 'Solve' in nmpc.nlp.return_status:
stats[i].add(nmpc.nlp.solve_time)
else: # max CPU time exceeded, infeasible problem detected, ...
fails[i] += 1.
yvals = [1000 * ts.avg if ts.avg is not None else 0. for ts in stats]
yerr = [1000 * ts.std if ts.std is not None else 0. for ts in stats]
pylab.bar(
xvals, yvals, width=step, yerr=yerr, color='y', capsize=5,
align='center', error_kw={'capsize': 5, 'elinewidth': 5})
pylab.xlim(start - step / 2, end + step / 2)
pylab.ylim(0, ymax)
pylab.grid(True)
if label is not None:
pylab.xlabel(label, fontsize=24)
pylab.ylabel('Comp. time (ms)', fontsize=20)
pylab.tick_params(labelsize=16)
pylab.twinx()
yfails = [100. * fails[i] / sample_size for i in xrange(len(xvals))]
pylab.plot(xvals, yfails, 'ro', markersize=12)
pylab.plot(xvals, yfails, 'r--', linewidth=3)
pylab.xlim(start - step / 2, end + step / 2)
pylab.ylabel("Failure rate [%]", fontsize=20)
pylab.tight_layout()
def wave_plotting(sonic, block=False):
if isinstance(sonic.wave_bin_data, list):
bin_buffer = bytearray()
for data in sonic.wave_bin_data:
bin_buffer.extend(data)
sonic.wave_bin_data = bytes(bin_buffer)
elif not isinstance(sonic.wave_bin_data, bytes):
raise Exception("Type of bin_data need bytes!")
#?????????????????????????????????????
wave_data = numpy.fromstring(sonic.wave_bin_data, dtype=number_type.get(sonic.sample_width))
#???????wave_data??????short???????????????????????
# ??????????????????LRLRLRLR....LR?L??????????R????????????wave_data?sharp
wave_data.shape = (sonic.sample_length, sonic.channels)
wave_data = wave_data.T
time = numpy.arange(0, sonic.sample_length) * (1.0 / sonic.sample_frequency)
# ????
colors = ['b', 'g', 'r', 'c', 'm', 'y', 'k']
pylab.figure()
for index in range(0, sonic.channels):
pylab.subplot(sonic.channels, 1, index + 1)
pylab.plot(time, wave_data[index], colors[index % len(colors)])
pylab.ylabel("quantization")
pylab.xlabel("time (seconds)")
pylab.ion()
if block:
pylab.ioff()
pylab.show()
def hinton(W, bg='grey', facecolors=('w', 'k')):
"""Draw a hinton diagram of the matrix W on the current pylab axis
Hinton diagrams are a way of visualizing numerical values in a matrix/vector,
popular in the neural networks and machine learning literature. The area
occupied by a square is proportional to a value's magnitude, and the colour
indicates its sign (positive/negative).
Example usage:
R = np.random.normal(0, 1, (2,1000))
h, ex, ey = np.histogram2d(R[0], R[1], bins=15)
hh = h - h.T
hinton.hinton(hh)
"""
M, N = W.shape
square_x = np.array([-.5, .5, .5, -.5])
square_y = np.array([-.5, -.5, .5, .5])
ioff = False
if plt.isinteractive():
plt.ioff()
ioff = True
plt.fill([-.5, N - .5, N - .5, - .5], [-.5, -.5, M - .5, M - .5], bg)
Wmax = np.abs(W).max()
for m, Wrow in enumerate(W):
for n, w in enumerate(Wrow):
c = plt.signbit(w) and facecolors[1] or facecolors[0]
plt.fill(square_x * w / Wmax + n, square_y * w / Wmax + m, c, edgecolor=c)
plt.ylim(-0.5, M - 0.5)
plt.xlim(-0.5, M - 0.5)
if ioff is True:
plt.ion()
plt.draw_if_interactive()
def __init__(self, **kwargs):
super(self.__class__, self).__init__(**kwargs)
self.update(**plt.rcParamsDefault)
plt.ion()
def __init__(self, fontSize=16., lineWidth=1., labelSize=None,
tickmajorsize=10, tickminorsize=5, figsize=(8, 6)):
if labelSize is None:
labelSize = fontSize + 2
rcParams = {}
rcParams['figure.figsize'] = figsize
rcParams['lines.linewidth'] = lineWidth
rcParams['grid.linewidth'] = lineWidth
rcParams['font.sans-serif'] = ['Helvetica']
rcParams['font.serif'] = ['Helvetica']
rcParams['font.family'] = ['Times New Roman']
rcParams['font.size'] = fontSize
rcParams['font.family'] = 'serif'
rcParams['font.weight'] = 'bold'
rcParams['axes.linewidth'] = lineWidth
rcParams['axes.labelsize'] = labelSize
rcParams['legend.borderpad'] = 0.1
rcParams['legend.markerscale'] = 1.
rcParams['legend.fancybox'] = False
rcParams['text.usetex'] = True
rcParams['image.aspect'] = 'auto'
rcParams['ps.useafm'] = True
rcParams['ps.fonttype'] = 3
rcParams['xtick.major.size'] = tickmajorsize
rcParams['xtick.minor.size'] = tickminorsize
rcParams['ytick.major.size'] = tickmajorsize
rcParams['ytick.minor.size'] = tickminorsize
rcParams['text.latex.preamble'] = ["\\usepackage{amsmath}"]
super(self.__class__, self).__init__(**rcParams)
plt.ion()
def __init__(self, fontSize=None, labelSize=None):
rcParams = {}
if fontSize is not None:
if labelSize is None:
labelSize = fontSize
rcParams['font.sans-serif'] = ['Helvetica']
rcParams['font.serif'] = ['Helvetica']
rcParams['font.family'] = ['Times New Roman']
rcParams['font.size'] = fontSize
rcParams["axes.labelsize"] = labelSize
rcParams["axes.titlesize"] = labelSize
rcParams["xtick.labelsize"] = labelSize
rcParams["ytick.labelsize"] = labelSize
rcParams["legend.fontsize"] = fontSize
rcParams['font.family'] = 'serif'
rcParams['font.weight'] = 'bold'
rcParams['axes.labelsize'] = labelSize
rcParams['text.usetex'] = True
rcParams['ps.useafm'] = True
rcParams['ps.fonttype'] = 3
rcParams['text.latex.preamble'] = ["\\usepackage{amsmath}"]
super(self.__class__, self).__init__(**rcParams)
plt.ion()
def plot_marginals(state_space,p,name,t,labels = False,interactive = False):
import matplotlib
import matplotlib.pyplot as pl
if interactive == True:
pl.ion()
pl.clf()
pl.suptitle("time: "+ str(t)+" units")
#print("time : "+ str(t))
D = state_space.shape[1]
for i in range(D):
marg_X = np.unique(state_space[:,i])
A = np.where(marg_X[:,np.newaxis] == state_space[:,i].T[np.newaxis,:],1,0)
marg_p = np.dot(A,p)
pl.subplot(int(D/2)+1,2,i+1)
pl.plot(marg_X,marg_p)
pl.yticks(np.linspace(np.amin(marg_p), np.amax(marg_p), num=3))
pl.axvline(np.sum(marg_X*marg_p),color= 'r')
pl.axvline(marg_X[np.argmax(marg_p)],color='g')
if labels == False:
pl.xlabel("Specie: " + str(i+1))
else:
pl.xlabel(labels[i])
if interactive == True:
pl.draw()
else:
pl.tight_layout()
pl.show()
def visualiseObject(self, cmap="hot"):
pylab.ion()
#pylab.set_cmap("gray")
pylab.gray()
pylab.title("image: %s" % self.fitsFile)
pylab.imshow(self.getObject(), interpolation="nearest", cmap=cmap)
pylab.colorbar()
pylab.ylim(-1, 2*self.extent)
pylab.xlim(-1, 2*self.extent)
pylab.xlabel("Pixels")
pylab.ylabel("Pixels")
pylab.show()
def visualiseObject(self, cmap="hot"):
pylab.ion()
#pylab.set_cmap("gray")
pylab.gray()
pylab.title("image: %s" % self.fitsFile)
pylab.imshow(self.getObject(), interpolation="nearest", cmap=cmap)
pylab.colorbar()
pylab.ylim(-1, 2*self.extent)
pylab.xlim(-1, 2*self.extent)
pylab.xlabel("Pixels")
pylab.ylabel("Pixels")
pylab.show()
def main(args):
# seed PRNG
np.random.seed(args.seed)
pl.ion()
if args.mode.startswith("test_"):
test_models(args)
else:
idim = None
# if args.mode.startswith("type03_1"):
# idim = 3
# print "args.goal_sample_interval", args.goal_sample_interval
# initialize experiment
inf = ActiveInferenceExperiment(
args.mode, args.model, args.numsteps,
idim = idim,
environment_str = args.environment,
goal_sample_interval = args.goal_sample_interval,
e2pmodel = args.e2pmodel,
saveplots = SAVEPLOTS)
# run experiment
inf.run()
# wait for plots to be closed
pl.ioff()
pl.show()
def __init__(self, modules, vis):
pylab.style.use('ggplot')
self.node_size_add = 1.5
self.init_node_size = 0.1
self.edge_weight_add = 0.1
self.init_edge_weight = 0.0
self.fixed_path = [[None] * 3] * 3
self.fixed_color = None
self.fixed_weight = 6.4
pylab.ion()
self.graph = nx.Graph()
self.node_ids = {}
node_num = 0
self.vis = vis
if not self.vis:
print("visualizing graph disabled!!")
for layer_num, one_layer in enumerate(modules):
for module_num in range(one_layer):
self.graph.add_node(node_num, Position=(10 * layer_num, 10 * module_num), size = self.init_node_size)
self.node_ids[(layer_num, module_num)] = node_num
node_num += 1
pylab.show()
def load(self):
self.output_attribute = self.config.get('output_attribute', 'prom')
self.feats = clist(self.config.get('features', ["F0", "Gain","dur"]))
self.prom_weights = clist(self.config.get('prom_weights', [0.4, 0.4, 0.2]))
self.param_dir = self.config.get('param_dir', 'acoustic')
self.frame_len = self.config.get('frame_length', 5)
self.level = self.config.get('level','//token[@token_class=\"word\"]')
self.scale_distance = float(self.config.get('scale_distance',0.5))
self.num_octaves = int(self.config.get('num_octaves', 12))
self.wscale = 10 ## this is set in training
self.variances = {} ## this is set in training
if CWT_DEBUG:
pylab.ion()
self.fzero_feat = ''
for f in self.feats:
if 'f0' in f.lower():
self.fzero_feat = f
assert self.fzero_feat != '', 'ProminenceLabeller needs a feature containing f0!'
self.dynamic_size_wavelet = str2bool(self.config.get('dynamic_size_wavelet', 'no'))
self.use_stress_track = str2bool(self.config.get('use_stress_track', 'no'))
self.stress_xpath = self.config.get('stress_xpath', '//syllable[@stress="stress_1"]')
## for plotting/debugging:-
self.text_attribute = self.config.get('text_attribute', 'text')
def main():
from argparse import ArgumentParser
p = ArgumentParser()
p.add_argument('--grammar', choices=('both', 'medium', 'big'))
p.add_argument('--rollout', choices=('CP', 'DP'))
args = p.parse_args()
CP = ('evalb_avg', 'pops')
DP = ('expected_recall_avg', 'mask')
GRAMMARS = ['medium', 'big'] if args.grammar == 'both' else [args.grammar]
ACC, RUN = DP if args.rollout == 'DP' else CP
pl.ion()
fig1, ax1 = pl.subplots(nrows=3, #sharex=True,
ncols=2, figsize=(10,10))
for i in range(3):
for j in range(2):
ax1[i,j].grid(False)
fig2, ax2 = pl.subplots(nrows=1, #sharex=True,
ncols=2, figsize=(10,5))
for i, GRAMMAR in enumerate(GRAMMARS):
plot(GRAMMAR, ACC, RUN, ax=ax1[:,i], col=i)
plot2(GRAMMAR, ACC, RUN, ax=ax2[i], col=i)
fig1.tight_layout()
fig2.tight_layout()
pl.ioff()
pl.show()
def check_matplotlib_backends():
# from http://stackoverflow.com/questions/5091993/list-of-all-available-matplotlib-backends
# get the directory where the backends live
backends_dir = os.path.dirname(matplotlib.backends.__file__)
# filter all files in that directory to identify all files which provide a backend
backend_fnames = filter(is_backend_module, os.listdir(backends_dir))
backends = [backend_fname_formatter(fname) for fname in backend_fnames]
print("supported backends: \t" + str(backends))
# validate backends
backends_valid = []
for b in backends:
try:
plt.switch_backend(b)
backends_valid += [b]
except:
continue
print("valid backends: \t" + str(backends_valid))
# try backends performance
for b in backends_valid:
pylab.ion()
try:
plt.switch_backend(b)
pylab.clf()
tstart = time.time() # for profiling
x = range(0,2*pylab.pi,0.01) # x-array
line, = pylab.plot(x,pylab.sin(x))
for i in range(1,200):
line.set_ydata(pylab.sin(x+i/10.0)) # update the data
pylab.draw() # redraw the canvas
print(b + ' FPS: \t' , 200/(time.time()-tstart))
pylab.ioff()
except:
print(b + " error :(")
def image_loop(self, decay, display_mode):
import pylab
fig = pylab.figure()
pylab.ion()
img = pylab.imshow(self.image, vmax=1, vmin=-1,
interpolation='none', cmap='binary')
pylab.xlim(0, 127)
pylab.ylim(127, 0)
regions = {}
if self.count_spike_regions is not None:
for k, v in self.count_spike_regions.items():
minx, miny, maxx, maxy = v
rect = pylab.Rectangle((minx - 0.5, miny - 0.5),
maxx - minx,
maxy - miny,
facecolor='yellow', alpha=0.2)
pylab.gca().add_patch(rect)
regions[k] = rect
if self.track_periods is not None:
colors = ([(0,0,1), (0,1,0), (1,0,0), (1,1,0), (1,0,1)] * 10)[:len(self.p_y)]
scatter = pylab.scatter(self.p_x, self.p_y, s=50, c=colors)
else:
scatter = None
while True:
img.set_data(self.image)
for k, rect in regions.items():
alpha = self.get_spike_rate(k) * 0.5
alpha = min(alpha, 0.5)
rect.set_alpha(0.05 + alpha)
if scatter is not None:
scatter.set_offsets(np.array([self.p_x, self.p_y]).T)
c = [(r,g,b,min(self.track_certainty[i],1)) for i,(r,g,b) in enumerate(colors)]
scatter.set_color(c)
if display_mode == 'quick':
# this is much faster, but doesn't work on all systems
fig.canvas.draw()
fig.canvas.flush_events()
else:
# this works on all systems, but is kinda slow
pylab.pause(0.001)
self.image *= decay
def images_loop(self, decays, display_mode):
import pylab
fig = pylab.figure()
num_images = len(decays)
pylab.ion()
imgs = []
for i in range(len(decays)):
fig.add_subplot(1, num_images, i+1)
imgs.append( pylab.imshow(self.images[i], vmax=1, vmin=-1,
interpolation='none', cmap='binary') )
pylab.xlim(0, 127)
pylab.ylim(127, 0)
regions = {}
if self.count_spike_regions is not None:
for k, v in self.count_spike_regions.items():
minx, miny, maxx, maxy = v
rect = pylab.Rectangle((minx - 0.5, miny - 0.5),
maxx - minx,
maxy - miny,
facecolor='yellow', alpha=0.2)
pylab.gca().add_patch(rect)
regions[k] = rect
if self.track_periods is not None:
colors = ([(0,0,1), (0,1,0), (1,0,0), (1,1,0), (1,0,1)] * 10)[:len(self.p_y)]
scatter = pylab.scatter(self.p_x, self.p_y, s=50, c=colors)
else:
scatter = None
while True:
for i,d in enumerate(decays):
imgs[i].set_data(self.images[i])
for k, rect in regions.items():
alpha = self.get_spike_rate(k) * 0.5
alpha = min(alpha, 0.5)
rect.set_alpha(0.05 + alpha)
if scatter is not None:
scatter.set_offsets(np.array([self.p_x, self.p_y]).T)
c = [(r,g,b,min(self.track_certainty[i],1)) for i,(r,g,b) in enumerate(colors)]
scatter.set_color(c)
if display_mode == 'quick':
# this is much faster, but doesn't work on all systems
fig.canvas.draw()
fig.canvas.flush_events()
else:
# this works on all systems, but is kinda slow
pylab.pause(0.001)
for i,d in enumerate(decays):
self.images[i] *= d
def image_loop(self, decay, display_mode):
import pylab
fig = pylab.figure()
pylab.ion()
img = pylab.imshow(self.image, vmax=1, vmin=-1,
interpolation='none', cmap='binary')
pylab.xlim(0, 127)
pylab.ylim(127, 0)
regions = {}
if self.count_spike_regions is not None:
for k, v in self.count_spike_regions.items():
minx, miny, maxx, maxy = v
rect = pylab.Rectangle((minx - 0.5, miny - 0.5),
maxx - minx,
maxy - miny,
facecolor='yellow', alpha=0.2)
pylab.gca().add_patch(rect)
regions[k] = rect
if self.track_periods is not None:
colors = ([(0,0,1), (0,1,0), (1,0,0), (1,1,0), (1,0,1)] * 10)[:len(self.p_y)]
scatter = pylab.scatter(self.p_x, self.p_y, s=50, c=colors)
else:
scatter = None
while True:
img.set_data(self.image)
for k, rect in regions.items():
alpha = self.get_spike_rate(k) * 0.5
alpha = min(alpha, 0.5)
rect.set_alpha(0.05 + alpha)
if scatter is not None:
scatter.set_offsets(np.array([self.p_x, self.p_y]).T)
c = [(r,g,b,min(self.track_certainty[i],1)) for i,(r,g,b) in enumerate(colors)]
scatter.set_color(c)
if display_mode == 'quick':
# this is much faster, but doesn't work on all systems
fig.canvas.draw()
fig.canvas.flush_events()
else:
# this works on all systems, but is kinda slow
pylab.pause(0.001)
self.image *= decay
def basic_sgd_demo(train_X, train_Y, val_X, val_Y, test_X, test_Y, config):
# This is to demonstrate the process of learning a simple one hidden-layer NN
# Input kernel: linear
# Num hidden layer: 1
# Learning method: SGD
# Parse param from config
lr = config['lr']
num_epoch = config['num_epoch']
num_train_per_class = config['num_train_per_class']
num_hidden_node = config['num_hidden_node']
display_rate = config['display_rate']
activation_function_type = config['activation_function']
num_train_sample = train_X.shape[0]
num_feature = train_X.shape[1]
num_class = train_Y.shape[1]
# Create a weight matrix of shape (2, num_hidden_node)
W1 = rng.randn(num_feature, num_hidden_node)
b1 = rng.randn(1, num_hidden_node)
# Create output weight
W2 = rng.randn(num_hidden_node, num_class)
b2 = rng.randn(1, num_class)
num_train_sample = 1
pylab.ion()
pylab.show()
all_cost = []
for i in range(0, num_epoch):
# Calculate the loss
a1 = np.dot(train_X, W1) + b1
z1 = activation_function(a1, activation_function_type)
a2 = np.dot(z1, W2) + b2
J = softmax_log_loss(a2, train_Y)
# Doing backprop
print('[Epoch %d] Train loss: %f' % (i, J))
dJ_dW1, dJ_db1, dJ_dW2, dJ_db2 = get_grad(train_X, train_Y, W1, b1, W2, b2, config)
# NumericalGradientCheck(train_X, train_Y, W1, b1, W2, b2, dJ_db1)
W1 = W1 - dJ_dW1 * lr
b1 = b1 - dJ_db1 * lr
W2 = W2 - dJ_dW2 * lr
b2 = b2 - dJ_db2 * lr
all_cost.append(J)
if (i % display_rate == 0):
config['train_method'] = 'sgd'
train_draw(train_X, train_Y, W1, b1, W2, b2, config, all_cost, i, J)
bp = 1
