def main(argv=None):
if argv is None:
argv = sys.argv
if len(argv) != 4:
print "Usage: " + argv[0] + " <report name> <report dir> <graph dir>"
return 1
report = argv[1]
report_dir = argv[2]
graph_dir = argv[3]
file_list = glob(os.path.join(report_dir, 'part*'))
#Copy the raw data file to the graph_dir
raw_file = os.path.join(graph_dir, report + '.tsv')
shutil.copyfile(file_list[0], raw_file)
#Process the file into a graph, ideally I would combine the two into one but for now I'll stick with two
data_file = csv.DictReader(open(raw_file, 'rb'), fieldnames = ['hour', 'Requests', 'Bytes'], delimiter="\t")
#Make an empty set will all the hours in it os if an hour is not in the data it will be 0
length = 24
requests_dict = {}
for num in range(length):
requests_dict['%0*d' % (2, num)] = (0, 0)
#add the values we have to the dictionaries
for row in data_file:
requests_dict[row['hour']] = (int(row['Requests']), int(row['Bytes']))
#Now get the lists for graphing in the right order
requests = []
num_bytes = []
requests_lists = requests_dict.items()
requests_lists.sort(key=lambda req: req[0])
for req in requests_lists:
requests.append(req[1][0])
num_bytes.append(req[1][1])
fig = pylab.figure(1)
pos = pylab.arange(length) + .5
pylab.bar(pos, requests[:length], aa=True, ecolor='r')
pylab.ylabel('Requests')
pylab.xlabel('Hour')
pylab.title('Request per hour')
pylab.grid(True)
#Save the figure
pylab.savefig(os.path.join(graph_dir, report + '_requests.pdf'), bbox_inches='tight', pad_inches=1)
#bytes listed
fig = pylab.figure(2)
pos = pylab.arange(length) + .5
pylab.bar(pos, num_bytes[:length], aa=True, ecolor='r')
pylab.ylabel('Bytes')
pylab.xlabel('Hour')
pylab.title('Bytes per hour')
pylab.grid(True)
#Save the figure
pylab.savefig(os.path.join(graph_dir, report + '_bytes.pdf'), bbox_inches='tight', pad_inches=1)
def stackedHistogram(data, bins=10, range=None, log = False, normed = False,
filename = None, labels = None,
**formating):
histograms = []
d1 = data[0]
curHist, bins = numpy.histogram(d1, bins = bins, range = range, normed = normed)
histograms.append(curHist)
for d in data[1:]:
curHist, bins = numpy.histogram(d, bins = bins, normed = normed)
histograms.append(curHist)
width = bins[1] - bins[0]
colors = 'b r k g c m y w'.split()
nRepeats = len(data) / len(colors)
for i in xrange(nRepeats):
colors = colors.extend(colors)
for histo, color in zip(histograms, colors):
pylab.bar(bins[:-1], histo[:-1], width = width, log=log,
edgecolor = color, facecolor = None)
doFormating(**formating)
pylab.show()
if filename is not None:
pylab.savefig(filename)
pylab.clf()
def plot_tuning_curves(direction_rates, title):
"""
This function takes the x-values and the y-values in units of spikes/s
(found in the two columns of direction_rates) and plots a histogram and
polar representation of the tuning curve. It adds the given title.
"""
x = direction_rates[:,0]
y = direction_rates[:,1]
plt.figure()
plt.subplot(2,2,1)
plt.bar(x,y,width=45,align='center')
plt.xlim(-22.5,337.5)
plt.xticks(x)
plt.xlabel('Direction of Motion (degrees)')
plt.ylabel('Firing Rate (spikes/s)')
plt.title(title)
plt.subplot(2,2,2,polar=True)
r = np.append(y,y[0])
theta = np.deg2rad(np.append(x, x[0]))
plt.polar(theta,r,label='Firing Rate (spikes/s)')
plt.legend(loc=8)
plt.title(title)
def distributionValues(y,bins=None):
if bins==None:
bins=int(sqrt(len(y)))
hist,bins=np.histogram(y,bins=bins)
plt.bar(bins[1:],hist,width=bins[1]-bins[0])
def eqDistribution(self, plot=True):
""" Obtain and plot the equilibrium probabilities of each macrostate
Parameters
----------
plot : bool, optional, default=True
Disable plotting of the probabilities by setting it to False
Returns
-------
eq : ndarray
An array of equilibrium probabilities of the macrostates
Examples
--------
>>> model = Model(data)
>>> model.markovModel(100, 5)
>>> model.eqDistribution()
"""
self._integrityCheck(postmsm=True)
macroeq = np.ones(self.macronum) * -1
for i in range(self.macronum):
macroeq[i] = np.sum(self.msm.stationary_distribution[self.macro_ofmicro == i])
if plot:
from matplotlib import pylab as plt
plt.ion()
plt.figure()
plt.bar(range(self.macronum), macroeq)
plt.ylabel('Equilibrium probability')
plt.xlabel('Macrostates')
plt.xticks(np.arange(0.4, self.macronum+0.4, 1), range(self.macronum))
plt.show()
return macroeq
def plot_fullstack( binning = np.linspace(0,10,1), myquery='', plotvar = default_plot_variable, \
scalefactor = 1., user_ylim = None):
fig = plt.figure(figsize=(10,6))
plt.grid(True)
lasthist = 0
myhistos = gen_histos(binning=binning,myquery=myquery,plotvar=plotvar,scalefactor=scalefactor)
for key, (hist, bins) in myhistos.iteritems():
plt.bar(bins[:-1],hist,
width=bins[1]-bins[0],
color=colors[key],
bottom = lasthist,
edgecolor = 'k',
label='%s: %d Events'%(labels[key],sum(hist)))
lasthist += hist
plt.title('CCSingleE Stacked Backgrounds',fontsize=25)
plt.ylabel('Events',fontsize=20)
if plotvar == '_e_nuReco' or plotvar == '_e_nuReco_better':
xstring = 'Reconstructed Neutrino Energy [GeV]'
elif plotvar == '_e_CCQE':
xstring = 'CCQE Energy [GeV]'
else:
xstring = plotvar
plt.xlabel(xstring,fontsize=20)
plt.legend()
plt.xticks(list(plt.xticks()[0]) + [binning[0]])
plt.xlim([binning[0],binning[-1]])
def plot_call_rate(c):
# Histogram
P.clf()
P.figure(1)
P.hist(c[:,1], normed=True)
P.xlabel('Call Rate')
P.ylabel('Portion of Variants')
P.savefig(os.environ['OBER'] + '/doc/imputation/cgi/call_rate.png')
####################################################################################
#if __name__ == '__main__':
# # Input parameters
# file_name = sys.argv[1] # Name of data file with MAF, call rates
#
# # Load data
# c = np.loadtxt(file_name, dtype=np.float16)
#
# # Breakdown by call rate (proportional to the #samples, 1415)
# plot_call_rate(c)
# h = np.histogram(c[:,1])
# a = np.flipud(np.cumsum(np.flipud(h[0])))/float(c.shape[0])
# print np.concatenate((h[1][:-1][newaxis].transpose(), a[newaxis].transpose()), axis=1)
# Breakdown by minor allele frequency
maf_n = 20
maf_bins = np.linspace(0, 0.5, maf_n + 1)
maf_bin = np.digitize(c[:,0], maf_bins)
d = c.astype(float64)
mean_call_rate = np.array([(1.*np.mean(d[maf_bin == i,1])) for i in xrange(len(maf_bins))])
P.bar(maf_bins - h, mean_call_rate, width=h)
P.figure(2)
h = (maf_bins[-1] - maf_bins[0]) / maf_n
P.bar(maf_bins - h, mean_call_rate, width=h)
P.savefig(os.environ['OBER'] + '/doc/imputation/cgi/call_rate_maf.png')
def plot_tuning_curves(direction_rates, title):
"""
This function takes the x-values and the y-values in units of spikes/s
(found in the two columns of direction_rates) and plots a histogram and
polar representation of the tuning curve. It adds the given title.
"""
# yank columns and keep in correspondance
directions = direction_rates[0:][:,0]
rates = direction_rates[0:][:,1]
# histogram plot
plt.subplot(2, 2, 1)
plt.title('Histogram ' + title)
plt.axis([0, 360, 0, 70])
plt.xlim(-22.5,337.5)
plt.xlabel('Directions (in degrees)')
plt.ylabel('Average Firing Rate (in spikes/s)')
plt.bar(directions, rates, width=45, align='center')
plt.xticks(directions)
# polar plot
plt.subplot(2,2,2,polar=True)
plt.title('Polar plot ' + title)
#plt.legend('Diring Rate (spikes/s)')
rates = np.append(rates, rates[0])
theta = np.arange(0,361,45)*np.pi/180
plt.polar(theta, rates)
plt.show()
# end plot_tuning_curves
return 0
def plotDist(subplot, X, Y, label):
pylab.grid()
pylab.subplot(subplot)
pylab.bar(X, Y, 0.05)
pylab.ylabel(label)
pylab.xticks(arange(len(X)), X)
pylab.yticks(arange(0,1,0.1))
def Importance_Plot(data,label=None):
'''
:param data: DATAFRAME style
:param label: y vector
:param threshold: jude threshold
:return: figure
'''
import numpy as np
import matplotlib.pylab as plt
from sklearn.ensemble import ExtraTreesClassifier
import pandas as pd
model=ExtraTreesClassifier()
data1=np.array(data)
model.fit(data1,label)
importance=model.feature_importances_
std = np.std([importance for tree in model.estimators_],axis=0)
indices = np.argsort(importance)[::-1]
namedata=data
# Print the feature ranking
print("Feature ranking:")
importa=pd.DataFrame({'importance':list(importance[indices]),'Feature name':list(namedata.columns[indices])})
print importa
# Plot the feature importances of the forest
plt.figure(figsize=(20, 8))
plt.title("Feature importances")
plt.bar(range(data1.shape[1]), importance[indices],
color="g", yerr=std[indices], align="center")
plt.xticks(range(data1.shape[1]), indices)
plt.xlim([-1, data1.shape[1]])
plt.grid(True)
plt.show()
def test_probabilities(exp, n=1000):
d = {}
for i in range(n):
foo = rp.parsex(exp)
# foo = len(foo.replace(' ',''))
if foo in d.keys():
d[foo] += 1
else:
d[foo] = 1
# lists = sorted(d.items())
# x, y = zip(*lists) # unpack a list of pairs into two tuples
# print x
# print y
# for a, b in zip(x, y):
# plt.text(a,b, str("%s\n%s" % (a, b)))
plt.xlabel("String length")
plt.ylabel("Occurence")
plt.title("Union: %s P=0.3 N=1000" % exp)
# plt.plot(x, y)
# For bar chart (use on Union)
# See for labeling: https://stackoverflow.com/a/30229062
l = sorted(d.items())
x, y = zip(*l)
plt.bar(range(len(y)), y, align="center")
plt.xticks(range(len(x)), x)
plt.show()
def show(self,H):
"""
Display the histogram of the data, together with the mixture model
Parameters
----------
H : ndarray
The histogram of the data.
"""
xmax = np.size(H)
sH = np.sum(H)
nH = H.astype(float)/sH
L = np.zeros(xmax)
ndraw = xmax-1
for i in range(xmax):
L0 = np.exp(self._bcoef(ndraw,i)+i*np.log(self.r0)+ \
(ndraw-i)*np.log(1-self.r0))
L1 = np.exp(self._bcoef(ndraw,i)+i*np.log(self.r1)+ \
(ndraw-i)*np.log(1-self.r1))
L[i] = self.Lambda*L0 + (1-self.Lambda)*L1
L = L/L.sum()
import matplotlib.pylab as mp
mp.figure()
mp.bar(np.arange(xmax),nH)
mp.plot(np.arange(xmax)+0.5,L,'k',linewidth=2)
def plotHousing(impression):
"""
生成房价随时间变化的图标
"""
f = open("midWestHousingPrices.txt", 'r')
#文件每一行是年季度价格
labels, prices = [], []
for line in f:
year, quarter, price = line.split()
label = year[2:4] + "\n Q" + quarter[1]
labels.append(label)
prices.append(float(price)/1000)
#柱的X坐标
quarters = np.arange(len(labels))
#柱宽
width = 0.5
if impression == 'flat':
plt.semilogy()
plt.bar(quarters, prices, width, color='r')
plt.xticks(quarters + width / 2.0, labels)
plt.title("美国中西部各州房价")
plt.xlabel("季度")
plt.ylabel("平均价格($1000)")
if impression == 'flat':
plt.ylim(10, 10**3)
elif impression == "volatile":
plt.ylim(180, 220)
elif impression == "fair":
plt.ylim(150, 250)
else:
raise ValueError("Invalid input.")
def plot_histogram(self, main="", numrows=1, numcols=1, fignum=1):
"""Plot a histogram of choices and probability sums. Expects probabilities as (at least) a 2D array.
"""
from matplotlib.pylab import bar, xticks, yticks, title, text, axis, figure, subplot
probabilities = self.get_probabilities()
if probabilities.ndim < 2:
raise StandardError, "probabilities must have at least 2 dimensions."
alts = probabilities.shape[1]
width_par = (1 / alts + 1) / 2.0
choice_counts = self.get_choice_histogram(0, alts)
sum_probs = self.get_probabilities_sum()
subplot(numrows, numcols, fignum)
bar(arange(alts), choice_counts, width=width_par)
bar(arange(alts) + width_par, sum_probs, width=width_par, color="g")
xticks(arange(alts))
title(main)
Axis = axis()
text(
alts + 0.5,
-0.1,
"\nchoices histogram (blue),\nprobabilities sum (green)",
horizontalalignment="right",
verticalalignment="top",
)
def plot_histogram_with_capacity(self, capacity, main=""):
"""Plot histogram of choices and capacities. The number of alternatives is determined
from the second dimension of probabilities.
"""
from matplotlib.pylab import bar, xticks, yticks, title, text, axis, figure, subplot
probabilities = self.get_probabilities()
if probabilities.ndim < 2:
raise StandardError, "probabilities must have at least 2 dimensions."
alts = self.probabilities.shape[1]
width_par = (1 / alts + 1) / 2.0
choice_counts = self.get_choice_histogram(0, alts)
sum_probs = self.get_probabilities_sum()
subplot(212)
bar(arange(alts), choice_counts, width=width_par)
bar(arange(alts) + width_par, capacity, width=width_par, color="r")
xticks(arange(alts))
title(main)
Axis = axis()
text(
alts + 0.5,
-0.1,
"\nchoices histogram (blue),\ncapacities (red)",
horizontalalignment="right",
verticalalignment="top",
)
def infer_latent_dim(X, verbose=0, maxr=-1):
"""
r = infer_latent_dim(X, verbose=0)
Infer the latent dimension of an aray assuming data+gaussian noise mixture
Parameters
----------
array X, data whose deimsnionhas to be inferred
verbose=0, int, verbosity level
maxr=-1, int, maximum dimension that can be achieved
if maxr = -1, this is equal to rank(X)
Returns
-------
r, int, the inferred dimension
"""
if maxr ==-1:
maxr = np.minimum(X.shape[0],X.shape[1])
U,S,V = nl.svd(X,0)
if verbose>1:
print "Singular Values", S
L = []
for k in range(maxr):
L.append(_linear_dim_criterion_(S,k,X.shape[1],X.shape[0])/X.shape[0])
L = np.array(L)
rank = np.argmax(L)
if verbose:
import matplotlib.pylab as mp
mp.figure()
mp.bar(np.arange(maxr),L-L.mean())
return rank
def plot_height(self):
"""Plot the height of the non-leaves nodes
"""
import matplotlib.pylab as mp
mp.figure()
sh = np.sort(self.height[self.isleaf() == False])
n = np.sum(self.isleaf() == False)
mp.bar(np.arange(n), sh)
def eqDistribution(self, plot=True):
if plot:
from matplotlib import pylab as plt
plt.bar(range(self.macronum), self.hmm.stationary_distribution)
#ax = plt.gca()
#ax.set_xticklabels([str(a) for a in self.hmm.active_set])
plt.xticks(np.arange(self.macronum)+0.4, [str(a) for a in self.hmm.active_set])
return self.hmm.stationary_distribution
def barplot(labels,data,error=None,bar_opts={},ticks_opts={}):
from matplotlib.pylab import bar,yticks,xticks,xlim
xlocations = [0.5+x for x in range(len(data))]
bar_opts.setdefault('width',0.5)
bar(xlocations, data, yerr=error, **bar_opts)
xticks([bar_opts['width']/2.0+x for x in xlocations], labels, **ticks_opts)
xlim(0, xlocations[-1]+1)
return xlocations
def LE(G, dim, verbose=0, maxiter=1000):
"""
Laplacian Embedding of the data
returns the dim-dimensional LE of the graph G
Parameters
----------
G, nipy.neurospin.graph.WeightedGraph instance that represents the data
dim=1, int, number of dimensions
verbose=0, verbosity level
maxiter=1000, int, maximum number of iterations of the algorithm
Returns
-------
chart, array of shape(G.V,dim)
Note
----
In fact the current implementation retruns
what is now referred to a diffusion map at time t=1
"""
n = G.V
dim = np.minimum(dim,n)
chart = nr.randn(G.V,dim+2)
f = ff.Field(G.V,G.edges,G.weights,chart)
LNorm,RNorm = local_sym_normalize(G)
# note : normally Rnorm = Lnorm
if verbose:
print np.sqrt(np.sum((LNorm-RNorm)**2))/np.sum(LNorm)
eps = 1.e-7
f1 = np.zeros((G.V,dim+2))
for i in range(maxiter):
f.diffusion(10)
f0 = Orthonormalize(f.field)
f.field = f0
if nl.norm(f1-f0)<eps:
break
else:
f1 = f0
if verbose:
print i,nl.norm(f1-f0)
f.diffusion()
f0 = f.field
U,S,V = nl.svd(f0,0)
RNorm = np.reshape(np.sqrt(RNorm),(n,1))
chart = S[:dim]*np.repeat(1./RNorm,dim,1)*U[:,1:dim+1]
chart = chart/np.sqrt(np.sum(chart**2,0))
if verbose:
import matplotlib.pylab as mp
mp.figure()
mp.bar(np.arange(np.size(S)-1),np.sqrt(1-S[1:]))
print "laplacian eigenvalues: ",1-S
return chart
def showSkyline(self, l):
pylab.cla()
for tpl in l:
st = tpl[0]
end = tpl[1]
height = tpl[2]
pylab.bar(st, height, (end - st))
pylab.show()
print "Done"
def plot_parm_imp(parms, equation):
"""plot for one set of variables"""
rank = loop_diff(parms, equation)
#sorted(rank, key=rank.get,reverse=True)
f1 = plot.figure()
variable = [i for i in rank]
value = [rank[str(i)] for i in rank]
plot.bar(variable, height=value, width=0.8)
plot.show()
def plot_results(results, title, xlabels, ylabel="Success Rate"):
'''Plot a bar graph of results'''
ind = np.arange(len(results))
width = 0.4
plt.bar(ind, results, width, color="#1AADA4")
plt.ylabel(ylabel)
plt.ylim(ymax=100)
plt.xticks(ind+width/2.0, xlabels)
plt.title(title)
def do_plot(stat):
ind = np.arange(len(CL))
w = 0.15
for i, c in enumerate(contexts):
vals = [ select(data, c, cl, stat) for cl in CL ]
plt.bar(ind + w*i, vals, w, color = COLORS[i])
plt.xticks(ind + 0.3, CL, rotation=0)
plt.ylabel(stat)
def show_time_difference(self,font,portfolioSize,timeSpent):
font.set_size(15)
sns.set(style="ticks")
pylab.figure(figsize=(12,8))
pylab.bar(portfolioSize,timeSpent,color = 'r',width=300)
pylab.grid(True)
pylab.title(u'期权计算时间耗时（单位：秒）',fontproperties = font,fontsize = 18)
pylab.ylabel(u'时间（s）',fontproperties = font,fontsize = 15)
pylab.xlabel(u'组合数量',fontproperties = font,fontsize = 15)
def plot(letter_frequency):
centers = range(len(alfa))
plt.bar(centers,
letter_frequency.values(),
align='center',
tick_label=letter_frequency.keys())
plt.xlim([0, len(alfa) - 1])
plt.show()
def getTweets(filename):
tweets = []
firstpo_date = []
tmlb=[]
f=open(filename)
for line in f:
try:
tweets.append(json.loads(line))
except:
print "error when reading tweets.txt"
#extract all the first post date into the list
for i in range(len(tweets)):
firstpo_date.append(tweets[i]['firstpost_date'])
#transfer the time stamp into actual time
timefrom=datetime.datetime.fromtimestamp(float(tweets[i]['firstpost_date'])).strftime('%H:%M:%S')
#store the actual time into tmlb
tmlb.append(timefrom)
hashtag=filename[7:-4]
intvl=tmlb[::100]
mintime = min(firstpo_date)
maxtime = max(firstpo_date)
num = len(firstpo_date)
delta = maxtime - mintime
print 'Mintime: ', mintime
print 'Maxtime: ', maxtime
period = delta / 3600
if (maxtime - mintime) % 3600 != 0:
period += 1
tweetphour = np.zeros(period) #create a list to count the number
for j in range(num):
for i in range(period):
if firstpo_date[j]>=(mintime+i*3600) and firstpo_date[j]<=(mintime+(i+1)*3600):
tweetphour[i] += 1
index = np.arange(len(tweetphour))
ax=plt.subplot(111)
plt.bar(index,tweetphour)
plt.xlabel('Time')
plt.ylabel('Number of Tweets')
plt.title('Number of Tweets Per Hour')
ax.set_xticklabels(intvl,rotation=20, rotation_mode="anchor", ha="right")
plt.legend()
plt.tight_layout()
plt.show()
return tweetphour
f.close()
def plot_data(hist):
X = np.arange(len(hist))
plt.bar(X, hist.values(), align='center', width=0.5)
plt.xticks(X, hist.keys())
locs, labels = plt.xticks()
plt.setp(labels, rotation=90)
ymax = max(hist.values()) + 0.1
plt.ylim(0, ymax)
plt.show()
def showSkyline(l):
pylab.cla()
for tuple in l:
st = tuple[0]
end = tuple[1]
height = tuple[2]
pylab.bar(st,height,(end-st))
pylab.show()
print "Done"
def plot_choice_patterns(choice_probabilities, task):
""" Function to produce plot for choice patterns.
"""
deciles = range(40)
colors = ['blue', 'yellow', 'orange', 'red']
width = 0.9
# Plotting
bottom = [0] * 40
# Initialize plot
ax = plt.figure(figsize=(12, 8)).add_subplot(111)
labels = ['Home', 'School', 'Occupation A', 'Occupation B']
for j, i in enumerate([3, 2, 0, 1]):
heights = choice_probabilities[:, i]
plt.bar(deciles,
heights,
width,
bottom=bottom,
color=colors[j],
alpha=0.70)
bottom = [heights[i] + bottom[i] for i in range(40)]
# Both Axes
ax.tick_params(labelsize=16,
direction='out',
axis='both',
top='off',
right='off')
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.spines['left'].set_visible(False)
# X axis
ax.set_xlabel('Period', fontsize=16)
ax.set_xlim([0, 40])
# Y axis
ax.set_ylabel('Share of Population', fontsize=16)
ax.yaxis.get_major_ticks()[0].set_visible(False)
# Legend
plt.legend(labels,
loc='upper center',
bbox_to_anchor=(0.5, -0.10),
fancybox=False,
frameon=False,
shadow=False,
ncol=4,
fontsize=20)
# Write out to
plt.savefig('choices_' + task + '.png', bbox_inches='tight', format='png')
def histogram(args):
""" Make a histogram over kmer overlaps for reads over reference, to
evaluate a proper cutoff value.
"""
import matplotlib.pylab as plt
from matplotlib.ticker import FuncFormatter
with open(args.reference) as fh:
fa = readfq(fh)
contams = [t[1] for t in fa]
k = args.k
kmers = set()
for contam in contams:
kmers |= set(str(contam[i:i + k]) for i in xrange(len(contam) - k))
kmers = frozenset(kmers)
fh = open(args.fastq)
fq = readfq(fh)
overlap = defaultdict(int)
for _, seq, _ in fq:
read_kmers = frozenset(seq[i:i + k] for i in xrange(len(seq) - k))
overlap[round(100 * float(len(read_kmers.intersection(kmers))) / len(seq), 0)] += 1
fh.close()
out_file = os.path.basename(args.fastq).replace('.fastq', '_kmer_histogram.png')
keys = sorted(overlap.keys())
nreads = sum(overlap.values())
percentages = [float(v) / nreads for v in overlap.values()]
cumulative = [float(overlap[keys[0]]) / nreads]
for key in keys[1:]:
cumulative.append(cumulative[-1] + float(overlap[key]) / nreads)
plt.bar(overlap.keys(), percentages, ec='none', label='histogram')
plt.plot(keys, cumulative, label='cumulative')
plt.gca().yaxis.set_major_formatter(FuncFormatter(prc_format))
plt.grid(True)
title = \
"""kmer overlap
k = {}
number of reads: {}"""
plt.title(title.format(k, nreads))
plt.xlabel('Overlapment')
plt.ylabel('% of reads')
plt.legend()
plt.tight_layout()
plt.savefig(out_file)
def get_random_mean_edges(G, gene_set, sims):
# ============================================
G = nx.Graph()
for line in open(network_file, 'r'):
# lines starting with '#' will be ignored
if line[0] == '#':
continue
# The first two columns in the line will be interpreted as an
# interaction gene1 <=> gene2
# 这个表的前两列将被解释为交互作用gene1<==>gene2
line_data = line.strip().split('\t')
# line.strip()删除数据中的换行符 .split('\t')遇到四个空格就隔开
node1 = line_data[0]
node2 = line_data[1]
# 定义node1为一组数据的前一项数据
# 定义node2为一组数据的后一项数据
G.add_edge(node1, node2)
all_genes_in_network = set(G.nodes())
tools.remove_self_links(G)
# print(list(G))
# =============================================
all_genes = G.nodes()
number_of_seed_genes = len(gene_set & set(all_genes))
# print(number_of_seed_genes)
# print(number_of_seed_genes)
edges_list = []
print("")
for i in range(1, sims + 1):
if i % 100 == 0:
sys.stdout.write("> random simulation [%s of %s]\r" % (i, sims))
sys.stdout.flush()
rand_seeds = set(random.sample(all_genes,number_of_seed_genes))
edges = get_edges_size(G, rand_seeds)
edges_list.append(edges)
# =============================================
def all_list(arr):
result2 = {}
for i in set(arr):
result2[i] = arr.count(i)
return result2
result2 = all_list(edges_list)
# result2[result2.keys()]=result2.pop()
# print(result)
x = result2.keys()
y = result2.values()
plt.xlabel('edges')
plt.ylabel('Frequency_percentage')
plt.bar(x, y)
plt.title('The histogram of the edges-Frequency_percentage')
plt.savefig('edges_final.pdf')
plt.close()
# =============================================
return edges_list
def display_lines_length(data):
dictionary = {}
for line in data['lines']:
length = len(line.split(' '))
count = dictionary.get(length, 0) + 1
dictionary[length] = count
x = [pair[0] for pair in dictionary.items()]
y = [pair[1] for pair in dictionary.items()]
plt.bar(x, y)
plt.show()
def plot_dropout(model, sort=True):
# Show dropout effect
do = model.dropout.detach().numpy().reshape(-1)
if sort:
do = np.sort(do)
plt.figure()
plt.bar(range(len(do)), do)
plt.suptitle(
f'Dropout probability of {model.lat_dim} fitted latent dimensions in Sparse Model'
)
def eqDistribution(self, plot=True):
if plot:
from matplotlib import pylab as plt
plt.bar(range(self.macronum), self.hmm.stationary_distribution)
#ax = plt.gca()
#ax.set_xticklabels([str(a) for a in self.hmm.active_set])
plt.xticks(
np.arange(self.macronum) + 0.4,
[str(a) for a in self.hmm.active_set])
return self.hmm.stationary_distribution
def plottrends(searchterm, tf, booRegion, booCreateCSV, secondtermforseries):
print('Importing data from Google Trends')
pytrend = TrendReq()
if booRegion or len(secondtermforseries) == 0:
search_list = [searchterm]
else:
search_list = [searchterm, secondtermforseries]
pytrend.build_payload(search_list, cat=0, timeframe=tf, geo='', gprop='')
register_matplotlib_converters()
plt.figure(figsize=(10, 6))
fig = plt.figure(1)
if booRegion:
df = pytrend.interest_by_region()
df.sort_values(searchterm, inplace=True, ascending=True)
df.reset_index(level=0, inplace=True)
df = df.tail(25)
ax = fig.add_subplot(111)
ax.tick_params(axis='x', which='major', labelsize=6)
ax.tick_params(axis='x', which='minor', labelsize=6)
ax.set_xticklabels(df['geoName'], rotation=50, ha="right")
plt.bar(df['geoName'], df[searchterm], color='grey')
plt.title("'" + searchterm + "'" +
' google searches by country over time : ' + tf)
else:
df = pytrend.interest_over_time()
df.reset_index(level=0, inplace=True)
plt.ylabel('Index')
plt.plot(df['date'], df[searchterm], color='black', label=searchterm)
if len(secondtermforseries) > 0:
plt.plot(df['date'],
df[secondtermforseries],
color='grey',
label=secondtermforseries)
searchterm = searchterm + ' \\ ' + secondtermforseries
plt.legend(loc="upper left")
plt.title("'" + searchterm + "'" + ' google searches through time : ' +
tf)
print(df.head())
if booCreateCSV:
print('Creating csv file')
df.to_csv('c:\\temp\\googletrends.csv')
plt.show()
def makeBarGraph(assm1_chrom_list, assm1_dict, assm1_name, assm2_chrom_list, assm2_dict, assm2_name, out_fi, data_type):
#check that chrom lists are the same- they should be but better to check
err=0
if [item for item in assm1_chrom_list if item in assm2_chrom_list]:
pass
else:
logging.critical("%s not in both lists" % item)
err += 1
if err>0:
logging.error("Chromosome lists not the same, not making graphic")
return
#set up lists for graphing
assm1_list=[]
assm2_list=[]
title=""
for seq in assm1_chrom_list:
if data_type == "collapse":
assm1_list.append(assm1_dict[seq].sp_len)
assm2_list.append(assm2_dict[seq].sp_len)
title="Collapse sequence: %s and %s" % (assm1_name, assm2_name)
elif data_type == "expand":
assm1_list.append(assm1_dict[seq].sp_only_len)
assm2_list.append(assm2_dict[seq].sp_only_len)
title="Expanded sequence: %s and %s" % (assm1_name, assm2_name)
elif data_type == "no_hit":
assm1_list.append(assm1_dict[seq].nohit_len)
assm2_list.append(assm2_dict[seq].nohit_len)
title="NoHit sequence: %s and %s" % (assm1_name, assm2_name)
elif data_type == "ungap_nohit":
assm1_list.append(assm1_dict[seq].ungap_nohit_len)
assm2_list.append(assm2_dict[seq].ungap_nohit_len)
title="Ungapped NoHit sequence: %s and %s" % (assm1_name, assm2_name)
else:
logging.error("Unknown data type, not making image: %s" % data_type)
return
#set up plot
sns.set_style("ticks")
sns.set_context("talk")
plt.figure(figsize=(20,10), dpi=100)
ax = plt.gca()
ax.get_xaxis().get_major_formatter().set_scientific(False)
X = np.arange(len(assm1_chrom_list))
width=0.5
y1_label=assm1_name
y2_label=assm2_name
plt.bar(X, assm1_list, width=0.5, facecolor='seagreen', edgecolor='none', label=y1_label)
plt.bar(X+0.5, assm2_list, width=0.5, facecolor="blue", edgecolor='none', label=y2_label)
plt.xticks(np.arange(len(assm1_list))+0.5, assm1_chrom_list, ha='center', size='22')
plt.yticks(size="22")
plt.xlabel('sequences', size='36')
plt.ylabel('number of bases', size='36')
plt.title(title, size='36')
plt.legend(loc='upper left', prop={'size':24})
sns.despine(top=True, right=True)
plt.savefig(out_fi, dpi=100)
def analyse_data(table, showMode=False, img_prefix=''):
'''Compute number of comments for each class, total number of articles, number of authors and number of tokens in data
Plot claim depending on non-believers and authors depending on number of comments
'''
labels = Counter()
articles = Counter()
authors = Counter()
count_tokens = Counter()
for (i, l) in enumerate(table['label']):
if not pandas.isna(l):
labels[l] += 1
if l == -1:
articles[table.iloc[i]['claim_id']] += 1
if not pandas.isna(table.iloc[i]['author']):
authors[table.iloc[i]['author']] += 1
for i, comment in enumerate(table['body']):
count_tokens.update(tokenize(comment))
if showMode:
print('For category "non-believer", we have', labels[-1], 'comments.')
print('For category "believer", we have', labels[1], 'comments.')
print('For category "none of the above", we have', labels[0],
'comments.')
print('Number of labelized articles', len(articles))
print('Number of authors on labelized data', len(authors))
print('Number of tokens in data', len(count_tokens))
nonBelievers = OrderedDict(
sorted(articles.items(), key=lambda pair: pair[1], reverse=True))
authors = OrderedDict(
sorted(authors.items(), key=lambda pair: pair[1], reverse=True))
plt.figure()
plt.xlabel('Claims', fontsize=15)
plt.ylabel('Number of non-believers', fontsize=15)
plt.plot(range(len(nonBelievers)), list(nonBelievers.values()))
plt.xticks([])
plt.savefig(STAT_PATH + img_prefix + 'nonBelievers.png')
if showMode:
plt.show()
plt.figure()
plt.xlabel('Authors', fontsize=15)
plt.ylabel('Number of comments', fontsize=15)
plt.bar(list(authors.keys()), list(authors.values()), width=.9)
plt.title("Author histogram")
plt.xticks([])
plt.savefig(STAT_PATH + img_prefix + 'comments.png')
if showMode:
plt.show()
return labels, articles, authors, count_tokens
def plot(results):
''' Plots the given results returned from 'perform' and stores the resulting
file in the submission folder. '''
_, size_of_largest_component, component_distribution = results
plt.bar(range(1, size_of_largest_component + 1), component_distribution)
plt.ylabel("Fraction of Nodes %")
plt.xlabel("Size of Component")
plt.title("Component Distribution")
plt.savefig("submission/components.png")
def lines_per_character(data):
dictionary = {}
for rank in data['character']:
count = dictionary.get(rank, 0) + 1
dictionary[rank] = count
x = [pair[0] for pair in dictionary.items()]
y = [pair[1] for pair in dictionary.items()]
plt.xlabel("Character")
plt.ylabel("Amount of lines")
plt.bar(x, y)
plt.show()
def plot(data, index):
plt.figure(index)
plt.bar(np.arange(len(data)),
data,
align='center',
alpha=0.5,
label="Rating Star = " + str(index))
plt.xlabel('Sentence Count')
plt.ylabel('Review Count')
plt.legend()
plt.show()
def plotProbabilityDetectionBar(self, results, confInterval):
# colors = ['brown', 'blue', 'darkgreen', 'red', 'black']
# xticks = [0, 1, 2, 3, 4]
# labels = [1, 2, 3, 4, 5]
n_groups = 5
index = numpy.arange(n_groups)
bar_width = 0.2
opacity = 0.7
fig, ax = plt.subplots(figsize=(13,8))
rects2 = plt.bar(index-bar_width, results[:,0], bar_width,
alpha=opacity,
color='lightslategrey',
yerr = confInterval['hop0'],
ecolor = 'black',
label='Node')
rects3 = plt.bar(index, results[:,1], bar_width,
alpha=opacity,
yerr = confInterval['hop1'],
ecolor = 'black',
color='cadetblue',
label='1 Hop Away')
rects1 = plt.bar(index + bar_width, results[:,2], bar_width,
alpha=opacity,
yerr = confInterval['hop2'],
ecolor = 'black',
color='seagreen',
label='2 Hops Away')
plt.xlabel('K', fontsize=fontlabel)
plt.ylabel('Detection Probability', fontsize=fontlabel)
# plt.title('Scores by group and gender')
plt.xticks(index + bar_width/2, ('1', '2', '3', '4', '5'))
ax.set_xlim((-2*bar_width, index[4]+3*bar_width))
ax.set_ylim((0,1))
ax.grid(c='gray')
legend = plt.legend(loc=1, fontsize=fontlabel)
legend.get_frame().set_alpha(0.5)
# plt.tight_layout()
# plt.show()
box = ax.get_position()
ax.set_position([box.x0, box.y0 + box.height * 0.1,
box.width, box.height * 0.9])
# Put a legend below current axis
ax.legend(loc='upper center', bbox_to_anchor=(0.5, -0.10),
fancybox=False, shadow=False, ncol=5, fontsize=fontlabel, frameon=False)
def dataAnalysis(cid,schoolYear,semester) :
host = '127.0.0.1'
user = '******'
password = '******'
database = 'cims'
port = 3306
mysql = pymysql.connect(host=host,user = user,password=password,database=database,port=port)
sql1 = "SELECT score,school_year,semester FROM tb_class_score_info WHERE cid = '" + cid +"' ORDER BY school_year,semester"
sql2 = "SELECT b.indicator_name,a.score FROM tb_first_index_score a,tb_evaluation_template b WHERE a.first_indicator_id = b.indicator_id and school_year = '" + schoolYear + "' and semester = " + str(semester)
print(sql2)
cursor1 = mysql.cursor()
cursor1.execute(sql1)
#得到一个元组，元组中有两条数据，第一条为学年，第二条为学期
result1 = cursor1.fetchall()
cursor1.close()
cursor2 = mysql.cursor()
cursor2.execute(sql2)
# 得到一个元组，元组中有两条数据，第一条为学年，第二条为学期
result2 = cursor2.fetchall()
cursor2.close()
x1 = []
y1 = []
for i in range(len(result1)) :
y1.append(result1[i][0])
x1.append(result1[i][1] + '-' + str(result1[i][2]))
x2 = []
y2 = []
for j in range(len(result2)) :
x2.append(result2[j][0])
y2.append(result2[j][1])
mysql.close()
#解决乱码问题
pyl.rcParams['font.sans-serif'] = ['KaiTi'] # 指定默认字体
pyl.rcParams['axes.unicode_minus'] = False
pyl.subplot(1,2,1)#行，列，当前区域
pyl.title('历史对比')
pyl.xlabel('时间')
pyl.ylabel('得分')
pyl.plot(x1,y1)
pyl.gcf().autofmt_xdate()
pyl.subplot(1,2,2)
pyl.title("指标得分")
pyl.xlabel("指标名称")
pyl.ylabel("得分")
pyl.bar(x2,y2,align='center')
pyl.show()
def ver_hist():
import matplotlib.pylab as plt
import numpy as np
x = [1, 2, 3, 4, 5, 6, 7, 8, 9]
xlabels = ["H", "B", "E", "G", "I", "T", "S", "U", "NF"]
y = [4265, 536, 3632, 587, 3, 1765, 1478, 4694, 196]
plt.bar(x, y)
plt.xticks(x, xlabels)
plt.show()
def plot_psds(data, rate, subject, condition, label_set, title):
"""
Plots the frequency response for all 9 channels
using the entire recording
"""
fig = plt.figure()
# common title
fig.suptitle('Frequency Response ('+title
+')'+subject+' '+condition,
fontsize=14, fontweight='bold')
# common ylabel
fig.text(0.06, 0.5, 'Normalized Power Spectral Density',
ha='center', va='center', rotation='vertical',
fontsize=14, fontweight='bold')
# common xlabel
fig.text(0.5, 0.05,'Frequency (Hz)',
ha='center', va='center',fontsize=14, fontweight='bold')
# use this to stack EEG, EOG, EMG on top of each other
sub_order = [1,4,7,10,2,5,3,6,9]
# determine max response to scale y-axis
maxY = 0
for i in range(0, len(data)):
Pxx, freqs = m.psd(data[i], NFFT=512, Fs=rate)
normalizedPxx = Pxx/sum(Pxx)
if normalizedPxx.max() > maxY:
maxY = normalizedPxx.max()
# plot all subplots
for i in range(0, len(data)):
plt.subplot(4, 3, sub_order[i]) # 4 x 3 layout
#plt.subplot(9, 1, i + 1) # vertical 9 x 1 layout
plt.subplots_adjust(hspace=.6) # adds space between subplots
Pxx, freqs = m.psd(data[i], NFFT=512, Fs=rate)
normalizedPxx = Pxx/sum(Pxx)
#plt.plot(freqs, normalizedPxx, label=label_set[ch])
plt.bar(freqs, normalizedPxx, label=label_set[i],width=0.2)
plt.axis([0,70,0,maxY])
plt.title(label_set[i])
#plt.xlabel('Frequency (Hz)')
#plt.ylabel('Normalized Power Spectral Density')
## Inserted into plotting loop
## Possible Classifier - calculate average power-weighted frequency
# sumPower = 0
# for j in range(0, len(normalizedPxx)):
# sumPower = sumPower + (normalizedPxx[j] * freqs[j])
#
# avgFreq = sumPower/len(freqs)
# print(channel_name[i] + " average frequency = " + str(avgFreq))
return
def plot_score_ratio(self, keyword):
results = self.data[self.data['sentence'].str.contains(keyword)]
ratio = [
len(results[results['score'] == 0]),
len(results[results['score'] == 1])
]
plt.bar(['negative', 'positive'], ratio)
plt.title(f"keyword: {keyword}")
plt.xlabel("score")
plt.ylabel("ratio")
plt.savefig("scoreRatio.png")
plt.show()
def compare_psds2(data1, data2, rate, subject, condition1, condition2,
channel, stage):
"""
Plot PSDs of 2 datasets
implements low-pass filter to eliminate 60 Hz noise
"""
Fcutoff = 55 # threshold for low-pass filter
fig = plt.figure()
# common title
fig.suptitle('Frequency Response ('+channel
+') - Subject #'+subject+' '+condition1+
' vs. '+condition2,
fontsize=14, fontweight='bold')
# common ylabel
fig.text(0.06, 0.5, 'Normalized Power Spectral Density',
ha='center', va='center', rotation='vertical',
fontsize=14, fontweight='bold')
# common xlabel
fig.text(0.5, 0.05,'Frequency (Hz)',
ha='center', va='center',fontsize=14, fontweight='bold')
# FFT for data1
df1 = runFFT(data1, rate, Fcutoff)
maxY = df1.nPxx.max()
# FFT for data2
df2 = runFFT(data2, rate, Fcutoff)
if df2.nPxx.max() > maxY:
maxY = df2.nPxx.max()
# overlay psds for baseline & recovery conditions
plt.subplot(2, 1, 1)
plt.bar(df1.freqs, df1.nPxx, label=condition1, width=0.2,
edgecolor = 'none')
plt.plot(df2.freqs, df2.nPxx, label=condition2, color='r')
plt.axis([0,Fcutoff,0,maxY])
#ax.axis.set_ticklabels([]) # hide x-axis labels on this subplot
plt.legend()
plt.title(stage)
fig.subplots_adjust(hspace=.35)
# plot differential between recovery & baseline conditions
plt.subplot(2, 1, 2)
plt.bar(df1.freqs, (df2.nPxx - df1.nPxx),
label='', width=0.2, color='r',
edgecolor = 'none')
plt.axis([0,Fcutoff,min(df2.nPxx - df1.nPxx),maxY])
plt.title(str(stage)+' Differential ('+str(condition1)+' - '
+str(condition2) +' )')
plt.show()
return
def barRecallPrecisionvsK2(self, recall, falseRate, precision, errorsRecall, errorprecision, errorFalse):
n_groups = len(recall)
fig, ax = plt.subplots(figsize=figsize)
index = numpy.arange(n_groups)
bar_width = 0.2
opacity = 0.7
rects2 = plt.bar(index-bar_width, precision, bar_width,
alpha=opacity,
color='goldenrod',
yerr = errorprecision,
ecolor = 'black',
edgecolor='black',
label='Precision',
hatch="//")
rects3 = plt.bar(index, recall, bar_width,
alpha=opacity,
color='darkorange',
edgecolor='black',
yerr = errorsRecall,
ecolor = 'black',
label='Recall',
hatch="xx")
rects1 = plt.bar(index + bar_width, falseRate, bar_width,
alpha=opacity,
yerr = errorFalse,
ecolor = 'black',
edgecolor='black',
color='firebrick',
label='False Rate',
hatch="--")
plt.xlabel('$K_{T}$', fontsize=fontlabel)
# plt.ylabel('Scores', fontsize=fontlabel)
plt.xticks(index + bar_width/2, ('1', '2', '3', '4', '5'))
ax.set_xlim((-2*bar_width, index[len(index)-1]+3*bar_width))
ax.set_ylim((0,1))
ax.grid(c='gray')
# legend = plt.legend(fontsize=fontlabel)
# legend.get_frame().set_alpha(0.5)
box = ax.get_position()
ax.set_position([box.x0, box.y0 + box.height * 0.1,
box.width, box.height * 0.9])
# Put a legend below current axis
ax.legend(loc='upper center', bbox_to_anchor=(0.5, +1.35),
fancybox=False, shadow=False, ncol=5, fontsize=fontlabel, frameon=False)
def plot_distribution(N, n1, n2):
'''Illustration: plot the distribution.'''
p = PairIntersectionSizePdf(N, n1, n2)
a, b = 0, min(n1, n2) + 1
pdf = [p.pdf(k) for k in xrange(a, b)]
P.figure(1)
P.clf()
P.bar(range(a, b), pdf)
P.xlabel('Intersection Size (k)')
P.ylabel('Probability')
P.title('PDF of Intersection Size of Two Sets of Sizes %d,%d Out Of %d' % (n1, n2, N))
P.show()
def plotRecordDistribution(df, timeline='M'):
"""plots records distribution according to timeline specified, options include
'month', 'date', 'year', given the date is of the form yyyy-mm-dd
Arguments:
- df: a dataFrame containing the column 'uploadDate'
- timeline: the unit of time on the time axis {'M':Month, 'W': Week, 'D':Day}
"""
try:
# Get the uploadDates and make em' a dataframe
uploadDate = pd.DataFrame()
uploadDate['date'] = pd.to_datetime(df['uploadDate'].dropna())
uploadDate.index = uploadDate['date']
uploadDate['score'] = 1 # one score to each upload
# Converting the uploadDate to the format of required frequency of sampling (month, day or year)
resampled_dates = uploadDate.resample(timeline).sum()
resampled_dates_plot_ticks = list(resampled_dates.index)
# plotting stuff
x_pos = np.arange(len(resampled_dates))
plt.figure(figsize=(16, 9))
plt.bar(x_pos, resampled_dates['score'])
if timeline == 'D':
resampled_dates_plot_ticks = [
x.strftime('%d %B %Y') for x in resampled_dates_plot_ticks
]
plt.xticks(x_pos[0:len(x_pos):10],
resampled_dates_plot_ticks[0:len(x_pos):10],
rotation='vertical')
timeline = 'Day'
elif timeline == 'W':
resampled_dates_plot_ticks = [
x.strftime('%d %B %Y') for x in resampled_dates_plot_ticks
]
plt.xticks(x_pos, resampled_dates_plot_ticks, rotation='vertical')
timeline = 'Week'
else:
resampled_dates_plot_ticks = [
x.strftime('%B %Y') for x in resampled_dates_plot_ticks
]
plt.xticks(x_pos, resampled_dates_plot_ticks, rotation='vertical')
timeline = 'month'
plt.xlabel(timeline, fontsize=15)
plt.ylabel('Number of submissions', fontsize=15)
plt.title('Submissions per ' + timeline, fontsize=18)
plt.xticks(fontsize=12)
plt.yticks(fontsize=12)
plt.show()
except:
print('Given table does not have column uploadDate')
def plot(data):
x, y = data
# plt.plot(x, y)
# plt.show()
index = np.arange(len(x))
plt.bar(index, y)
plt.xlabel('File', fontsize=5)
plt.ylabel('Size', fontsize=5)
plt.xticks(index, x, fontsize=5, rotation=30)
plt.title('LRU files and size')
plt.show()
def PredictNSteps(NSteps):
for i in range(0, NSteps):
CurrentPrediction = GetPrediction()
print(str(XVal[-1] + 1) + ' : ' + str(CurrentPrediction))
DeltaXVal.append(XVal[-1] + 1)
DeltaYVal.append(float(CurrentPrediction))
XVal.append(XVal[-1] + 1)
YVal.append(float(CurrentPrediction))
plt.bar(XVal, YVal)
plt.bar(DeltaXVal, DeltaYVal, color='red')
plt.show()
def plot_class_frequencies(labels):
freqs = group(labels)
plt.figure(figsize=(15, 5))
plt.bar(freqs[:, 0], freqs[:, 1])
plt.xlabel('ClassID')
plt.ylabel('Frequency')
ind = np.arange(0.5, 43.5)
plt.xticks(ind,
get_label_map('signnames.csv', np.unique(labels)),
ha='right',
rotation=45)
plt.show()
def plot_attack(data, class_distrs_clean, class_distrs_attacked, node_id,
retrain_iters):
def make_xlabel(ix, correct):
if ix == correct:
return "Class {}\n(correct)".format(ix)
return "Class {}".format(ix)
figure = plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
center_ixs_clean = []
for ix, block in enumerate(class_distrs_clean.T):
x_ixs = np.arange(len(block)) + ix * (len(block) + 2)
center_ixs_clean.append(np.mean(x_ixs))
color = '#555555'
if ix == data.y[node_id].item():
color = 'darkgreen'
plt.bar(x_ixs, block, color=color)
ax = plt.gca()
plt.ylim((-.05, 1.05))
plt.ylabel("Predicted probability")
ax.set_xticks(center_ixs_clean)
ax.set_xticklabels([
make_xlabel(k, data.y[node_id].item())
for k in range(info["num_classes"])
])
ax.set_title(
"Predicted class probabilities for node {} on clean data\n({} re-trainings)"
.format(node_id, retrain_iters))
fig = plt.subplot(1, 2, 2)
center_ixs_attacked = []
for ix, block in enumerate(class_distrs_attacked.T):
x_ixs = np.arange(len(block)) + ix * (len(block) + 2)
center_ixs_attacked.append(np.mean(x_ixs))
color = '#555555'
if ix == data.y[node_id].item():
color = 'darkgreen'
plt.bar(x_ixs, block, color=color)
ax = plt.gca()
plt.ylim((-.05, 1.05))
ax.set_xticks(center_ixs_attacked)
ax.set_xticklabels([
make_xlabel(k, data.y[node_id].item())
for k in range(info["num_classes"])
])
ax.set_title(
"Predicted class probabilities for node {} after {} perturbations\n({} re-trainings)"
.format(node_id, info_attack["n_perturbations"], retrain_iters))
plt.tight_layout()
plt.show()
def barChartPlot(index, coefficients, expected=[]):
"""
Plots a bar chart with Zernike coefficients, `:math: C_{i}`.
Parameters
----------
index : list of ints
Indices of the polynomial coefficients.
coefficients : array
Coefficients of the Zernike polynomials.
expected : array, optional
Expected values of the coefficients.
"""
fig = plt.figure(figsize=(9, 6), dpi=80)
xticklist = []
width = 0.6
# Prepare the labels of the x ticks.
for i in index:
xticklist.append('Z' + str(i))
barfigure = plt.bar(index,
coefficients,
width,
color='#2E9AFE',
edgecolor='#2E9AFE',
label='Measured')
if len(expected) > 0:
plt.bar(index - width / 3,
expected,
width,
color='#882255',
edgecolor='#882255',
label='Input',
alpha=0.5)
# Add a legend.
plt.legend(loc=0, fancybox=True)
# Set the ticks and their labels.
plt.xticks(index + width // 2, xticklist, rotation=90)
plt.xlabel('Zernike polynomials', fontsize=18)
plt.ylabel('Coefficient', fontsize=18)
plt.title('Fitted Zernike polynomial coefficients', fontsize=18)
plt.gca().minorticks_on()
plt.gca().tick_params('both', direction='in', top=True, right=True)
plt.gca().tick_params('y',
which='minor',
direction='in',
left=True,
right=True)
plt.gca().tick_params('x', which='minor', bottom=False)
def plot_trigger_timmdiff():
f = open(sys.argv[1])
triggers = []
ini = True
iniini = True
last_trigger = 0
for line in f.readlines():
if iniini:
iniini = False
continue
try:
if ini:
last_line = line.split()
last_trigger = last_line[0].split('(')[1]
last_trigger = last_trigger.split(',')[0]
ini = False
continue
this_line = line.split()
this_trigger = this_line[0].split('(')[1]
this_trigger = this_trigger.split(',')[0]
difference = (float(this_trigger) -
float(last_trigger)) / 1000000
print(difference)
triggers.append(difference)
last_trigger = this_trigger
except:
pass
xmax = max(triggers)
pulsebins = n.linspace(0, xmax, xmax + 1)
# pulsebins = n.linspace(0, xmax, 1000)
hist0 = n.histogram(n.array(triggers), bins=pulsebins)
# print(xmax)
# print(pulsebins)
baredges0 = n.linspace(0, hist0[1][-1], len(hist0[0]))
p.ylim(ymax=1.2 * max(hist0[0]))
# pulsebins = hist0[1]
p.bar(baredges0, hist0[0], width=pulsebins[1] - pulsebins[0],
color='b', label='triggers')
p.grid()
p.legend()
p.xlabel('Triggerdistance')
p.ylabel('Events')
p.show()
def plotData(Data, nObsPlot=5000):
''' Plot data items, at most nObsPlot distinct points (for quick rendering)
'''
if type(Data) == bnpy.data.XData:
PRNG = np.random.RandomState(nObsPlot)
pIDs = PRNG.permutation(Data.nObs)[:nObsPlot]
if Data.dim > 1:
pylab.plot(Data.X[pIDs,0], Data.X[pIDs,1], 'k.')
else:
hist, bin_edges = pylab.histogram(Data.X, bins=25)
xs = bin_edges[:-1]
ys = np.asarray(hist, dtype=np.float32) / np.sum(hist)
pylab.bar(xs, ys, width=0.8*(bin_edges[1]-bin_edges[0]), color='k')
def plot_hist(centers, i):
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
plt.bar(np.arange(20), centers / np.sum(centers))
#plt.grid(axis='y', alpha=0.75)
plt.xlabel('cluster')
my_x_ticks = np.arange(0, 20, 1)
plt.xticks(my_x_ticks)
plt.ylabel('Probability')
plt.title('Histogram for the cluster centers %d' % i)
plt.text(23, 45, r'$\mu=15, b=3$')
plt.savefig('cluster_' + str(i) + '.eps')
def draw_state_frequency_percentage(values):
max_frequency = 200
figures = values[:, 0]
indexes = np.arange(max_frequency)
percentages = []
for i in range(max_frequency):
percentages.append(len(np.argwhere(figures > i)) / len(figures) * 100)
plt.bar(indexes + 0.1, percentages)
plt.title("State Frequency Percentage")
plt.xlabel("State Frequency")
plt.ylabel("Percentage")
plt.show()
