def animate_plotting(subdir_path,):
average_filename = 'averaged_out.txt'
if os.path.exists( os.path.join(subdir_path,average_filename) ):
print(subdir_path+average_filename+' already exists please use hotPlot.py')
#import existing data for average at the end
# data_out = numpy.genfromtxt(os.path.join(subdir_path,average_filename))
# averaged_data = numpy.array(data_out[:,1])
# angles = data_out[:,0]
#os.remove( os.path.join(subdir_path,average_filename))
else:
files = os.listdir(subdir_path)
#files = [d for d in os.listdir(subdir_path) if os.path.isdir(os.path.join(subdir_path, d))]
onlyfiles_path = [os.path.join(subdir_path,f) for f in files if os.path.isfile(os.path.join(subdir_path,f))]
onlyfiles_path = natsort.natsorted(onlyfiles_path)
averaged_data = []
angles = []
for f in onlyfiles_path:
data = numpy.genfromtxt(f,delimiter = ',')
#data = pandas.read_csv(f)
averaged_data.append(numpy.mean(data))
angle = os.path.basename(f).split('_')[0]
angles.append(float(angle))
fig = plt.plot(angles, averaged_data,'o')
plt.yscale('log')
plt.xscale('log')
plt.legend(loc='upper right')
plt.title(base_path)
plt.grid(True)
plt.xlabel(r'$\theta$ $[deg.]}$')
#plt.xlabel(r'$\mathrm{xlabel\;with\;\LaTeX\;font}$')
plt.ylabel(r'I($\theta$) $[a.u.]$')
def genCurve(dataSet, tree):
x = [] # stores the x axis of the graph
trainList = [] # the list of accuracies derived from training data
valList = [] # the list of accuracies derived from validation data
i = 0
while i < 1:
i = i+0.1
a = 0
b = 0
for trial in range(3):
newData = sortData(dataSet, i) # MAKE THIS
tree = getTree(newData) # NEED TO GET THIS FUNCTION WHEN TREEGEN WORKS
a = a + model_validation.validateTree(tree, newData)
b = b + model_validation.validateTree(tree, newData)
a = float(a)/3
b = float(b)/3
trainList.append(a)
valList.append(b)
x.append(i)
plt.plot(x, trainList)
plt.plot(x, valList)
plt.xlabel('percent training used')
plt.ylabel('percent accuracy')
plt.title('learning curve')
plt.show()
def plotDataFrame(self, variables):
try:
import matplotlib.pyplot as plt
except ImportError:
print "Unable to import matplotlib"
plt.plot(self.df[variables[0]], self.df[variables[1]])
plt.xlabel(r"{}".format(variables[0]))
plt.ylabel(r"$P$")
plt.minorticks_on()
plt.show()
def plot2D(x,y,x_ex,y_ex,ylabl):
#static variable counter
plot2D.fig_num += 1
plt.subplot(2,2,plot2D.fig_num)
plt.xlabel('$x$ (cm)')
plt.ylabel(ylabl)
plt.plot(x,y,"b+-",label="Lagrangian")
plt.plot(x_ex,y_ex,"r--",label="Exact")
plt.savefig("var_"+str(plot2D.fig_num)+".pdf")
def generate_plot(array, vmin, vmax, figNumber=1):
plt.figure(figNumber)
plt.subplot(2,3,i)
print i
plt.imshow(array, vmin = vmin, vmax= vmax, interpolation = None)
plt.xlabel('Sample')
plt.ylabel('Line')
plt.title(row[0])
cb = plt.colorbar(orientation='hor', spacing='prop',ticks = [vmin,vmax],format = '%.2f')
cb.set_label('Reflectance / cos({0:.2f})'.format(incAnglerad*180.0/math.pi))
plt.grid(True)
def plot_f_score(self, disag_filename):
plt.figure()
from nilmtk.metrics import f1_score
disag = DataSet(disag_filename)
disag_elec = disag.buildings[building].elec
f1 = f1_score(disag_elec, test_elec)
f1.index = disag_elec.get_labels(f1.index)
f1.plot(kind='barh')
plt.ylabel('appliance');
plt.xlabel('f-score');
plt.title(type(self.model).__name__);
def plot(self, output):
plt.figure(figsize=output.fsize, dpi=output.dpi)
for ii in range(0, len(self.v)):
imsize = [self.t[0], self.t[-1], self.x[ii][-1], self.x[ii][0]]
lim = amax(absolute(self.v[ii])) / output.scale_sat
plt.imshow(self.v[ii], extent=imsize, vmin=-lim, vmax=lim, cmap=cm.gray, origin='upper', aspect='auto')
plt.title("%s-Velocity for Trace #%i" % (self.comp.upper(), ii))
plt.xlabel('Time (s)')
plt.ylabel('Offset (km)')
#plt.colorbar()
plt.savefig("Trace_%i_v%s.pdf" % (ii, self.comp))
plt.clf()
def plot2D(x,y,ylabl,x_ex=None,y_ex=None):
#static variable counter
plot2D.fig_num += 1
plt.subplot(2,2,plot2D.fig_num)
plt.xlabel('$x$ (cm)')
plt.ylabel(ylabl)
plt.plot(x,y,"b+-",label="Numerical")
if (x_ex != None):
plt.plot(x_ex,y_ex,"r-x",label="Exact")
plt.savefig("var_"+str(plot2D.fig_num)+".pdf")
def viz_losses(filename, losses):
if '.' not in filename: filename += '.png'
x = history['epoch']
legend = losses.keys
for v in losses.values: plt.plot(np.arange(len(v)) + 1, v, marker='.')
plt.title('Loss over epochs')
plt.xlabel('Epochs')
plt.xticks(history['epoch'], history['epoch'])
plt.legend(legend, loc = 'upper right')
plt.savefig(filename)
def plot_confusion_matrix(cm, labels, title='Confusion matrix', cmap=plt.cm.Blues, save=False):
plt.figure()
plt.imshow(cm, interpolation='nearest', cmap=cmap)
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(labels))
plt.xticks(tick_marks, labels, rotation=45)
plt.yticks(tick_marks, labels)
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')
plt.show()
if save:
plt.savefig(save)
def print_scatter_data():
import matplotlib.pylab as plt
filename = Par.dirname + ('/Scatter.dat')
fitnesses = []
self_reliences = []
life_times = []
self_reliences_dead = []
for Agent in Par.Agents:
if Agent.dead != True:
fitnesses.append(Agent.fitness)
Needs = Agent.needs
Production = Agent.production
selfReli = [0.0]*Par.num_resources
for i in range(Par.num_resources):
selfReli[i] = Production[i]*Needs[i]
self_reliences.append(abs(sum(selfReli)))
else:
life_time = Agent.t_death - Agent.t_discovery
life_times.append(life_time)
Needs = Agent.needs
Production = Agent.production
selfReli = [0.0]*Par.num_resources
for i in range(Par.num_resources):
selfReli[i] = Production[i]*Needs[i]
self_reliences_dead.append(abs(sum(selfReli)))
file =open(filename, 'w')
for i in range(len(fitnesses)):
s= str(fitnesses[i]) +' '+ str(self_reliences[i])
file.write(s)
file.write('\n')
file.close()
plt.scatter(self_reliences, fitnesses)
plt.ylabel('Fitness')
plt.xlabel('self_reliences')
plt.savefig('FitnessVSR.png')
plt.close()
plt.scatter(self_reliences_dead, life_times)
plt.ylabel('LifeTimes')
plt.xlabel('self_reliences')
plt.savefig('LifeTimeVSR.png')
plt.close()
def plot_data():
import matplotlib.pylab as plt
t, suffering = np.loadtxt('suffering.dat', unpack= True, usecols = (0,1))
t, fitness = np.loadtxt('fitness.dat', unpack = True, usecols = (0,1))
plt.plot(t, suffering)
plt.xlabel('t')
plt.ylabel('suffering')
plt.savefig('suffering.png')
plt.close()
plt.plot(t, fitness)
plt.xlabel('t')
plt.ylabel('fitness')
plt.savefig('fitness.png')
plt.close()
def blca(datafile,numprocs):
#run c++ blocking routine, saves txt data file with blocking data
os.system("make --silent")
os.system("mpirun -n %i blocking.out 100 3000 2 %i %s"%(nprocs,numprocs,datafile))#VMC
#os.system("mpirun -n %i blocking.out 5000 100 20000 %i %s"%(nprocs,numprocs,datafile))#DMC
#read txt file and save plot
data = np.genfromtxt(fname=datafile+'.txt')
fig=plt.figure()
plt.plot(data[:,0],data[:,2],'k+')
plt.xlabel(r'$\tau_{trial}$', size=20)
plt.ylabel(r'$\epsilon$', size=20)
plt.xlim(np.min(data[:,0]),np.max(data[:,0]))
plt.ylim(np.min(data[:,2]),np.max(data[:,2]))
fig.savefig(datafile+'.eps',format='eps')
#open plot if -p in argv
if plot_res:
os.system('evince %s%s '%(datafile+'.eps','&'))
print("plot saved : %s"%(datafile+'.eps'))
def __save(self,n,plot,sfile):
p.figure(figsize=sfile)
p.xlabel(plot.xlabel)
p.ylabel(plot.ylabel)
p.xscale(plot.xscale)
p.yscale(plot.yscale)
p.grid()
for curve in plot.curves:
if curve[1] == None: p.plot(curve[0],curve[2], label=curve[3])
else: p.plot(curve[0], curve[1], curve[2], label=curve[3])
p.rc('legend', fontsize='small')
p.legend(shadow=0, loc='best')
p.axes().set_aspect(plot.aspect)
if not plot.dir: plot.dir = './plots/'
if not plot.name: plot.name = self.__global_name+'_%0*i'%(2,n)
if not os.path.isdir(plot.dir): os.mkdir(plot.dir)
if plot.pgf: p.savefig(plot.dir+plot.name+'.pgf')
else: p.savefig(plot.dir+plot.name+'.pdf', bbox_inches='tight')
p.close()
def plot_confusion_matrix(cm, classes,
normalize=False, title='Confusion matrix',
cmap=plt.cm.Blues, filename='viz\\confusion_matrix.png'):
plt.figure()
plt.imshow(cm, interpolation='nearest', cmap=cmap)
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=45)
plt.yticks(tick_marks, classes)
if normalize: cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
thresh = cm.max() / 2.
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
plt.text(j, i, cm[i, j], horizontalalignment="center", color="white" if cm[i, j] > thresh else "black")
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')
plt.savefig(filename)
def plot(self, model, output):
Z = linspace(0, model.number[2] * model.spacing[2], model.number[2]) + model.spacing[2]
imsize = [model.origin[0], model.size[0] + model.origin[0], model.origin[1], model.size[1] + model.origin[1]]
fig = plt.figure(figsize=(output.hres / output.sres, output.hres / (output.sres * output.hratio)),
dpi=output.sres)
vimg = plt.imshow(transpose(self.v[:, :, 0]), extent=imsize, vmin=round(amin(self.v), 1) - 0.05, vmax=round(amax(self.v) + 0.05, 1),
cmap=cm.jet)
vtitle = plt.title('')
plt.xlabel('X')
plt.ylabel('Y')
plt.colorbar()
def animate(ii):
vimg.set_array(transpose(self.v[:, :, ii]))
vtitle.set_text("%s Plot (Z = %1.2fkm)" % (self.name, Z[ii]))
return vimg, vtitle
try:
ani = animation.FuncAnimation(fig, animate, frames=len(Z), interval=20, blit=False, repeat=False)
ani.save("./%s.mp4" % self.type, fps=30, codec='libx264', bitrate=1800)
except IndexError:
print 'To render movies, make sure that ffmpeg is installed!'
def display(self, data, candidates, fname, display):
finallist=[]
for c in candidates:
finallist.append(c[0])
#print finallist
part1 = finallist[:len(finallist)/2]
part2 = finallist[len(finallist)/2:]
meandiff=int(np.sqrt(np.power(np.mean(part2),2)-np.power(np.mean(part1),2)))
rangeA = max(part1)-min(part1)
rangeB = max(part2)-min(part2)
span = int((rangeA+rangeB)/2)
dspan = int(meandiff/span)
theta = float(meandiff/(rangeA+rangeB))
oneortwo=""
if dspan >3 and meandiff > 20 or meandiff>36:
oneortwo = "Two distributions \n\n MD: %d \n Span: %d \n Dspan: %d \n theta: %d" % (meandiff, span, dspan, theta)
else:
oneortwo = "One distribution \n\n MD: %d \n Span: %d \n Dspan: %d \n theta: %d" % (meandiff, span, dspan, theta)
cans = np.array(candidates)
plt.plot(cans[:,0],cans[:,1],'ro')
plt.axhline(max(cans[:,1])/4, color='r')
plt.axhline(max(cans[:,1]/2), color='r')
plt.axhline(int(max(cans[:,1]))*0.75, color='r')
red_patch = mpatches.Patch(color='red', label='75%, 50% and 25% \nof maximum frequency')
plt.legend(handles=[red_patch])
plt.ylabel('Frequency of occurence')
plt.xlabel('separate items')
plt.title('Frequency distribution estimation graph: %s' %(fname))
plt.text(max(data)*1.1, max(cans[:,1])*0.62, oneortwo, fontsize = 11, color = 'r')
plt.hist(data,range(int(min(data)),int(max(data)),1))
ofile = fname[0:-3]+"png"
print ("Writing outfile: %s") % (ofile)
plt.savefig(ofile, bbox_inches='tight')
if display == True:
plt.show()
return;
def execute():
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
x = random.normal(5, .5, 1000)
y = random.normal(3, 1, 1000)
a = x*cos(pi/4) + y*sin(pi/4)
b = -x*sin(pi/4) + y*cos(pi/4)
plt.plot(a, b, '.')
plt.xlabel('x')
plt.ylabel('y')
plt.title('原数据集')
data = zeros((1000, 2))
data[:, 0] = a
data[:, 1] = b
x, y, evals, evecs = pca(data, 1)
print(y)
plt.figure()
plt.plot(y[:, 0], y[:, 1], '.')
plt.xlabel('x')
plt.ylabel('y')
plt.title('重新构造数据')
plt.show()
def plot(self, output):
# Create adaptive scale
scale_len = 100
scale_fix = 250
nframes = self.v.shape[2]
scale = zeros((nframes, 1))
win = ones((scale_len, 1))
for ii in range(0, nframes):
scale[ii] = amax(absolute(self.v[:, :, ii]))
scale = convolve(squeeze(scale), squeeze(win), mode='same') / output.scale_sat
if (self.writestep == 0):
scale[:scale_fix] = scale[scale_fix]
# Initialize figure
comp = {'x': ['Y', 'Z'], 'y': ['X', 'Z'], 'z': ['X', 'Y']}
fig = plt.figure(figsize=(output.hres / output.sres, output.hres / (output.sres * output.hratio)),
dpi=output.sres)
imsize = [self.x[0], self.x[-1], self.y[-1], self.y[0]]
vimg = plt.imshow(transpose(self.v[:, :, 0]), extent=imsize, vmin=-scale[0], vmax=scale[0], cmap=cm.RdBu)
vtitle = plt.title('')
plt.xlabel(comp[self.dir][0])
plt.ylabel(comp[self.dir][1])
plt.colorbar()
def animate(ii):
vimg.set_array(transpose(self.v[:, :, ii]))
vimg.set_clim(-scale[ii], scale[ii])
vtitle.set_text("%s for %s=%s km (t=%1.2e s)" % (self.type, self.dir, self.loc, self.t[ii]))
return vimg, vtitle
try:
ani = animation.FuncAnimation(fig, animate, frames=self.v.shape[2], interval=20, blit=False, repeat=False)
if (self.writestep == 0):
ani.save("./%s_%s_%s.mp4" % (self.dir, self.loc, self.type), fps=30, codec='libx264', bitrate=1800)
else:
ani.save("./%s_%s_%s_%i.mp4" % (self.dir, self.loc, self.type, self.writestep), fps=30, codec='libx264', bitrate=1800)
except IndexError:
print 'To render movies, make sure that ffmpeg is installed!'
self.writestep += 1
def plotdatatree(treeID, scale1, mass1):
plot_title="Mass Accretion History Tree " + str(treeID) #Can code the number in with treemax
x_axis="scale time"
y_axis="total mass"
figure_name=os.path.expanduser('~/figureTree' + str(treeID))
#Choose which type of plot you would like: Commented out.
plt.plot(scale1, mass1, linestyle="-", marker="o")
#plt.scatter(scale1, mass1, label="first tree")
plt.title(plot_title)
plt.xlabel(x_axis)
plt.ylabel(y_axis)
#plt.yscale("log")
plt.savefig(figure_name)
#In order to Plot only a single tree on a plot must clear lists before loop.
#Comment out to over plot curves.
plt.clf()
clearmass = []
clearscale = []
return clearmass, clearscale
eye_sample, eye_line = row[1:3]
nose_sample, nose_line = row[3:5]
print eye_sample, eye_line, nose_sample, nose_line
print "opening",bg_file[0]
cube = gdal.Open(bg_file[0], GA_ReadOnly )
xOff = int(eye_sample) - size/2 -1
yOff = int(eye_line) - size/2 -1
array = cube.ReadAsArray(xOff, yOff, size, size)
array = array / math.cos(incAnglerad)
means.append(array.mean())
if i == 1 and vmin == None:
vmin = array.min()
vmax = array.max()
print vmin,vmax
generate_plot(array, vmin, vmax)
xOff = int(nose_sample) - size/2 -1
yOff = int(nose_line) - size/2 -1
array = cube.ReadAsArray(xOff, yOff, size, size)
array = array/math.cos(incAnglerad)
means2.append(array.mean())
generate_plot(array, vmin,vmax, 3)
plt.figure(2)
plt.plot(times,means,'bo')
plt.xlabel('L_s [deg]')
plt.ylabel('Reflectance / cos(i) for {0}x{0} pixels'.format(size))
plt.title('mean(BG) vs L_s, eye-crater')
plt.plot(times,means2,'ro')
plt.show()
import matplotlib as plt
# X-axis sorted for making the graph clean from crazy lines all over and just a single line
print(plt.style.available)
plt.style.use("dark_background")
forest_fires = forest_fires.sort(["rain"])
plt.plot(forest_fires["rain"], forest_fires["area"])
# Set the x axis label
plt.xlabel("Amount of Rain")
# Set the y axis label
plt.ylabel("Area")
# Set the title
plt.title("Rain quantity vs fire area")
plt.show()
def create_figure_surface(figid, aspect, xx, yy, cmin, cmax, levels, slices, v3d):
''' creates a plot of the surface of a tracer data
Parameters
----------
figid : int
id of figure
aspect: float
aspect ratio of figure
xx : array
scale of x axis
yy : array
scale of y axis
cmin,cmax : array
minimum and maxminm of the color range
levels : array
range of contourlines
slices : array
location of slices
v3d : vector data in geometry format
Returns
-------
plot : of surface data
'''
# prepare matplotlib
import matplotlib
matplotlib.rc("font",**{"family":"sans-serif"})
matplotlib.rc("text", usetex=True)
#matplotlib.use("PDF")
import matplotlib.pyplot as plt
# basemap
from mpl_toolkits.basemap import Basemap
# numpy
import numpy as np
# data
vv = v3d[0,:,:,0]
# shift
vv = np.roll(vv, 64, axis=1)
# plot surface
plt.figure(figid)
# colormap
cmap = plt.cm.bone_r
# contour fill
p1 = plt.contourf(xx, yy, vv, cmap=cmap, levels=levels, origin="lower")#, hold="on")
plt.clim(cmin, cmax)
# contour lines
p2 = plt.contour(xx, yy, vv, levels=levels, linewidths = (1,), colors="k")#, hold="on")
plt.clabel(p2, fmt = "%2.1f", colors = "k", fontsize = 14)
#plt.colorbar(p2,shrink=0.8, extend='both')
# slices
#s1 = xx[np.mod(slices[0]+64, 128)]
#s2 = xx[np.mod(slices[1]+64, 128)]
#s3 = xx[np.mod(slices[2]+64, 128)]
# print s1, s2, s3
#plt.vlines([s1, s2, s3], -90, 90, color='k', linestyles='--')
# set aspect ratio of axes
plt.gca().set_aspect(aspect)
# basemap
m = Basemap(projection="cyl")
m.drawcoastlines(linewidth = 0.5)
# xticks
plt.xticks(range(-180, 181, 45), range(-180, 181, 45))
plt.xlim([-180, 180])
plt.xlabel("Longitude [degrees]", labelpad=8)
# yticks
plt.yticks(range(-90, 91, 30), range(-90, 91, 30))
plt.ylim([-90, 90])
plt.ylabel("Latitude [degrees]")
# write to file
plt.savefig("solution-surface", bbox_inches="tight")
plt.show()
filename = assembly + '-trackspacing-errors.h5'
if os.path.isfile('results/' + filename):
f = h5py.File('results/' + filename, 'r')
else:
f = h5py.File('results/' + assembly + '-errors.h5', 'r')
for j, x in enumerate(x_axis):
value_keys = f[test][sorted_keys[j]].keys()
for key in value_keys:
if 'Kinf_Error' in key:
kinf_list.append(f[test][sorted_keys[j]][key][...]*10**5)
plt.plot(x_axis,kinf_list, colors[i] + 'o-', ms = 10, lw = 2)
f.close()
plt.axis([max(x_axis), 0, 0, 400])
plt.title('Error in K-Infinity')
plt.xlabel('Track Spacing [cm]')
plt.ylabel('K-Infinity Error [pcm]')
plt.grid()
plt.legend(legend)
plt.show()
fig.savefig('K-Infinity-Error-TS.png')
fig = plt.figure()
for i, assembly in enumerate(assembly_list):
mean_list = []
filename = assembly + '-trackspacing-errors.h5'
if os.path.isfile('results/' + filename):
f = h5py.File('results/' + filename, 'r')
else:
f = h5py.File('results/' + assembly + '-errors.h5', 'r')
for j, x in enumerate(x_axis):
# TODO: Display an image along with the top 5 classes
model.eval()
class_names = []
# Process Image
image_path = 'input2.png'
# Give image to model to predict output
probs, classes, image = predict(image_path, model)
print('probs: {} and classes: {}'.format(probs, classes))
print(probs, classes)
print(cat_to_name)
print(model.class_to_idx)
#probs=probs.detach.numpy()
#classes=classes.detach.numpy()
print(probs, classes)
print(classes[0])
for i in classes[0]:
class_names.append(model.class_to_idx.item(int(classes[0, i])))
print(class_names)
for c in classes:
class_names.append(cat_to_name[c])
print('classnames: {}'.format(class_names))
# Show the image
ax = imshow(image)
plt.barh(probs, class_names)
plt.xlabel('Probability')
plt.title('Predicted Flower Names')
plt.show()
#%% Make a column that is the logfoldchange from post to pre
dfpre['foldchange'] = (dfpre['linabundpost']-dfpre['linabundpre'])
#dfpre['foldchange'] = ((dfpre['linabundpost']/npost)-(dfpre['linabundpre']/npre))/(dfpre['linabundpre']/npre)
print(dfpre['foldchange'].unique())
foldchangevec = dfpre['foldchange']
#%% Look at fold change and log fold change for each cell and its correpsonding lineage
dfpre['logfoldchange'] = np.log(dfpre['foldchange'])
dfpre['logfoldchange']= dfpre['logfoldchange'].fillna(0)
print(dfpre['logfoldchange'].unique())
# Figures of logfold change and fold change
plt.figure()
plt.hist(dfpre['logfoldchange'], range = [3, 7], bins = 100)
plt.xlabel('log(foldchange) of lineage abundance')
plt.ylabel('number of cells')
plt.figure()
plt.hist(dfpre['foldchange'],range = [0, 500], bins = 100)
plt.xlabel('foldchange of lineage abundance')
plt.ylabel('number of cells')
#%% Make the survivor column, but don't label it yet.
#dfpre['survivor'] =np.where(dfpre['linabundpost'] >1000, 'res','sens'
# Want to call cells that have an increase in lineage abundance resistant
dfpre.loc[dfpre.foldchange>0, 'survivor'] = 'res'
dfpre.loc[dfpre.foldchange<-200, 'survivor']= 'sens'
height_shift_range=0,
shear_range=0,
zoom_range=0,
horizontal_flip=True,
fill_mode='nearest',
# preprocessing_function = contrast_adjusment,
# preprocessing_function = HE,
preprocessing_function=AHE)
datagen.fit(x_train)
print("Running augmented training now, with augmentation")
history = model.fit_generator(
datagen.flow(x_train, y_train, batch_size=batch_size),
steps_per_epoch=x_train.shape[0], # batch_size,
epochs=epochs,
validation_data=(x_test, y_test))
else:
print("Running regular training, no augmentation")
history = model.fit(x_train,
y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(x_test, y_test))
plt.plot(history.epoch, history.history['val_acc'], '-o', label='validation')
plt.plot(history.epoch, history.history['acc'], '-o', label='training')
plt.legend(loc=0)
plt.xlabel('epochs')
plt.ylabel('accuracy')
plt.grid(True)
print(confusion_matrix(labels2, prediction2))
print('Classification Report')
target_names = ['Benign', 'Malignant']
print(classification_report(labels2, prediction2, target_names=target_names))
#%%
fpr_keras, tpr_keras, thresholds_keras = roc_curve(test_labels,
predictions_all)
auc_keras = auc(fpr_keras, tpr_keras)
plt.figure(1)
plt.plot([0, 1], [0, 1], 'k--')
plt.plot(fpr_keras, tpr_keras, label='Keras (area = {:.3f})'.format(auc_keras))
plt.xlabel('False positive rate')
plt.ylabel('True positive rate')
plt.title('ROC curve')
plt.legend(loc='best')
plt.show()
#%%
prediction2 = model.predict_classes(data3)
from sklearn.metrics import classification_report, confusion_matrix
print('Confusion Matrix')
print(confusion_matrix(labels2, prediction2))
print('Classification Report')
target_names = ['Benign', 'Malignant']
print(classification_report(labels2, prediction2, target_names=target_names))
def show_target_scatter_plot(colum_name):
plt.scatter(train[colum_name], train['price'])
plt.xlabel(colum_name)
plt.ylabel('price')
plt.title('Price VS ' + colum_name)
transformed parameters {
vector[nholes] d_hat;
for (i in 1:nholes)
d_hat[i] <- avg + p[i] + holes[i];
}
model {
dist ~ normal(d_hat, sigma);
}"""
unpooled_data = {
'nholes': 2000,
'players': df['Player'], # Stan counts starting at 1
'holes': df['Hole'],
'dist': df['Distance']
}
sm = pystan.StanModel(model_code=unpooled_model)
unpooled_fit = sm.sampling(data=unpooled_data, iter=1000, chains=2)
unpooled_estimates = pd.Series(unpooled_fit['a'].mean(0), index=player_names)
unpooled_se = pd.Series(unpooled_fit['a'].std(0), index=player_names)
order = unpooled_estimates.sort_values().index
plt.figure(figsize=(18, 6))
plt.scatter(range(len(unpooled_estimates)), unpooled_estimates[order])
for i, m, se in zip(range(len(unpooled_estimates)), unpooled_estimates[order],
unpooled_se[order]):
plt.plot([i, i], [m - se, m + se], 'b-')
plt.xlim(-1, 690)
plt.ylabel('Price estimate (log scale)')
plt.xlabel('Ordered category')
plt.title('Variation in category price estimates')
df['violation_bins'] = first_word_violation.apply(assign_vio_bin)
# create dummy variables for each 'violation'
#dummy_df = pd.get_dummies(df['violation_bins'], prefix = 'violation')
# Combine the two datasets
#df = pd.concat([df, dummy_df], axis =1)
df.boxplot(column='driver_age',
by='driver_race',
showfliers=False,
figsize=(6, 6))
import matplotlib.pyplot as plt
plt.hist(df['driver_age'], bins=30, histtype='stepfilled')
plt.xlabel('Age of Driver')
plt.title('Distribution of Age')
plt.show()
pd.crosstab(df['month_label'], df['is_arrested']).plot(kind='bar')
plt.title('Arrest Frequency for Month')
plt.xlabel('Month')
plt.ylabel('Frequency of Arrest')
arrested = df[df['is_arrested'] == 1]
pd.crosstab(df['month_label'], arrested['is_arrested']).plot(kind='bar')
df.groupby('driver_gender').boxplot(column='driver_age',
by='month_label',
showfliers=False,
figsize=(14, 6))
###I installed pip and matplotlib. matplotlib is recognized, but doesn't do anything yet.###
import matplotlib as plt
# Scatter plot
plt.scatter(gdp_cap, life_exp)
# Previous customizations
plt.xscale('log')
plt.xlabel('GDP per Capita [in USD]')
plt.ylabel('Life Expectancy [in years]')
plt.title('World Development in 2007')
# Definition of tick_val and tick_lab
tick_val = [1000, 10000, 100000]
tick_lab = ['1k', '10k', '100k']
# Adapt the ticks on the x-axis
plt.xticks(tick_val, tick_lab)
# After customizing, display the plot
plt.show()
Y = list(data_subset[to_plot])
Y_err = [0] * len(Y)
# Y_err = list(data_subset[to_plot + '_std'])
# plt.errorbar(T[:], Y[:], yerr = Y_err, markersize = 5, marker = 'o', label = type)
plt.plot(T[3:], Y[3:], markersize = 5, lw = 3, marker = 'o', label = type[4:-8] + ' spins')
# if i == 0:
# plt.plot(T[:], Y[:], markersize = 5, lw = 3, marker = 'o', label = '1D')
# elif i == 1 :
# plt.plot(T[1:], Y[1:], markersize = 5, lw = 3, marker = 'o', label = '1.5D')
# elif i == 2 :
# plt.plot(T[1:], Y[1:], markersize = 5, lw = 3, marker = 'o', label = '2D')
# else:
# plot(T[7:], Y[7:], markersize = 5, lw = 3, marker = 'o', label = '2.5D')
plt.xlabel('$T$', fontsize = 20)
plt.ylabel('$E$', fontsize = 20, rotation = 'horizontal', labelpad = 25)
#plt.axvline(x = 2.2, lw = 5, color = 'k', alpha = 0.2)
plt.subplots_adjust(left = 0.15, right = 0.92, top = 0.92, bottom = 0.15)
plt.tick_params(axis = 'both', which = 'major', labelsize = 20)
plt.xlim(left = 0, right = 5)
plt.ylim(bottom = -2.1, top = 0)
legend = plt.legend(fontsize = 18, loc = 2)
show()
plt.plot(tStart, fStart)
plt.plot(tStart, NStart)
else:
plt.plot(t, f)
plt.plot(t, N)
plt.ylabel("kraft[N]")
plt.legend(["Rullefriksjon", "Normalkraft"])
elif thingToPlot == "vel":
vAbs = []
#for el in v:
vAbs= np.abs(v)
tData = []
vData = []
for i in range(len(malingData)):
tData.append(malingData[i][0])
vData.append(malingData[i][3])
plt.plot(t, vAbs)
plt.plot(tData, vData)
plt.ylabel("fart[m/s]")
plt.legend(["Teoretisk", "Eksperimentelt"])
plt.xlabel("tid[s]")
#plt.show()
plt.savefig("test.png", dpi=900)
print(x[len(x)-1], xData[len(xData)-1])
def boton_vector_normalf(self):
Pop_Up = tk.Tk()
Pop_Up.title("Rango Tiempo")
Pop_Up.minsize(400, 300)
L1 = tk.Label(Pop_Up, text="Eliga Tiempo a Evaluar")
posicion = ttk.Frame(L1)
posicion.pack(side=tk.LEFT, expand=True, padx=5, pady=5)
E1 = ttk.Entry(posicion, justify=tk.CENTER)
E1.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
E1.insert(tk.END, "5")
L1.pack()
label = tk.Label(Pop_Up)
label.pack()
frame_arriba = ttk.Frame(Pop_Up)
hola = round(tiempo_maximov1, 2)
strhola = str(hola)
inter = "Intervalo de tiempo= [0, "
suma = inter + strhola + "]"
frame_arriba.pack(side=tk.TOP,
fill=tk.BOTH,
expand=True,
padx=5,
pady=5)
tiempo_init = ttk.Label(frame_arriba, text=suma)
tiempo_init.pack(side=tk.TOP)
tiempo_init_x = ttk.Entry(frame_arriba,
state='readonly',
justify='center')
tiempo_init_x.insert(0, "0")
button = ttk.Button(Pop_Up,
text='Evaluar',
width=10,
command=Pop_Up.destroy)
button.pack(side=tk.BOTTOM)
# inicializa la ventana popup
tiempofinal = 20
xo = int(self.entrada_posicion_x0.get())
yo = int(self.entrada_posicion_y0.get())
vxo = 15
vyo = 90
angulo_inicial = self.entrada_angulo_inicial.get()
mpl.title("Vector Normal")
mpl.xlabel("-X-")
mpl.ylabel("-Y-")
x = np.arange(0, tiempofinal, 0.001)
print(E1.get())
x1 = 5
h = math.sin(math.degrees(angulo_inicial))
j = math.cos(math.degrees(angulo_inicial))
print(h)
x1 = 2
y = yo + vyo * x + (1 / 2) * -9.8 * x**2
z = xo + vxo * x + (1 / 2) * 0 * x**2
y1 = yo + vyo * x1 + (1 / 2) * -9.8 * x1**2
z1 = xo + vxo * x1 + (1 / 2) * 0 * x1**2
vector_velocidadx = (vxo * x1)
vector_velocidady = (vyo * h - (9.8 * x1))
mpl.plot(z, y, "-")
mpl.plot(vector_velocidadx + z1, vector_velocidady + y1, "-o")
mpl.plot((vector_velocidady + z1), (vector_velocidadx), "-o")
mpl.plot(z1, y1, "-o")
mpl.show()
pass
gs.fit(X_train, y_train)
'''
xgb_model.fit(X_train, y_train)
#model.fit(X_train,y_train)
y_pred = xgb_model.predict(X_test)
predictions = [value for value in y_pred]
print("Predictions!!!!!!!!!!!!!!!!!!!!!!!!!!")
print(predictions)
pickle.dump(xgb_model, open("xgbmodel.pickle", "wb"))
'''
with open('xgbmodel.pickle', mode='wb') as f:
pickle.dump(model, f)
'''
#loaded_model = pickle.load(open("xgbmodel.pickle.dat", "rb"))
plt.plot(y_test, color='red', label='percentage_teacher')
plt.plot(predictions, color='blue', label='percentage')
plt.plot(y_real_test, color='green', label='Real Price')
plt.title('Cripto currency prediction')
plt.xlabel('Time')
plt.ylabel('green:Real Price blue: prediction(%) red: teacher(%)')
plt.legend()
plt.show()
print("FINAL money")
print(trade.simulate_trade(y_real_test, X_test, model))
def boton_aceleracionf(self):
#funcion para la obtencion de tiempo impacto final
def time_impact(self):
t = ((self.velocidad_inicial * sin(self.angulo)) /
(2 * self.gravedad)) + (
(1 / self.gravedad) *
(sqrt(((self.velocidad_inicial * sin(self.angulo))**2) +
(2 * self.y0 * self.gravedad))))
print(t)
return t
# funcion para el calculo de la coordenada horizontal
def cord_x(self, t):
x = self.x0 + ((self.velocidad_inicial * cos(self.angulo)) * t)
return x
# funcion para el calculo de la coordenada vertical
def cord_y(self, t):
y = self.y0 + (((self.velocidad_inicial *
(cos(self.angulo))) * t) - ((self.gravedad / 2) *
(t**2)))
return y
# funcion altura maxima para graficar
def altura_max(self):
r = self.y0 + (((self.velocidad_inicial * (sin(self.angulo)))**2) /
(2 * self.gravedad))
return r
# funcion alcance maximo para graficar
def alcance_max(self):
alc = self.x0 + ((self.velocidad_inicial*sin(2*self.angulo))/(2*self.gravedad)) + \
((self.velocidad_inicial*cos(self.angulo)) /
(self.gravedad))*sqrt(((self.velocidad_inicial*sin(self.angulo))**2) + 2*self.y0*self.gravedad)
return alc
# pop up de ingreso de datos
Pop_Up = tk.Tk()
Pop_Up.title("Aceleracion")
frame_arriba = ttk.Frame(Pop_Up)
frame_centro = ttk.Frame(Pop_Up)
frame_abajo = ttk.Frame(Pop_Up)
frame_evaluar = ttk.Frame(Pop_Up)
frame_salir = ttk.Frame(Pop_Up)
frame_arriba.pack(side=tk.TOP,
fill=tk.BOTH,
expand=True,
padx=5,
pady=5)
frame_centro.pack(side=tk.TOP,
fill=tk.BOTH,
expand=True,
padx=5,
pady=5)
frame_abajo.pack(side=tk.TOP,
fill=tk.BOTH,
expand=True,
padx=5,
pady=5)
frame_evaluar.pack(side=tk.TOP,
fill=tk.BOTH,
expand=True,
padx=5,
pady=5)
frame_salir.pack(side=tk.TOP,
fill=tk.BOTH,
expand=True,
padx=5,
pady=5)
tiempo = ttk.Label(frame_abajo, text="Tiempo(s):")
aceptar = ttk.Button(frame_evaluar, text="ACEPTAR")
tiempo_init = ttk.Label(frame_arriba, text="Intervalo de tiempo")
tiempo_init_x = ttk.Entry(frame_arriba,
state='readonly',
justify='center')
tiempo_init_y = ttk.Entry(frame_arriba, state='readonly')
tiempo_init.pack(side=tk.TOP)
tiempo_init_x.pack(side=tk.LEFT,
fill=tk.BOTH,
expand=True,
padx=5,
pady=5)
tiempo_init_y.pack(side=tk.LEFT,
fill=tk.BOTH,
expand=True,
padx=5,
pady=5)
tiempo_init_x.configure(state='normal')
tiempo_init_x.delete(0, 'end')
tiempo_init_x.insert(0, "0")
tiempo_init_x.configure(state='readonly')
# inicializa el punto de interseccion del eje Y
tiempo_init_y.configure(state='normal')
tiempo_init_y.delete(0, 'end')
tiempo_init_y.insert(0, time_impact(self))
tiempo_init_y.configure(state='readonly')
# Separador de datos
separador = ttk.Separator(frame_centro, orient="horizontal")
separador.pack(side=tk.TOP, expand=False, fill=tk.X)
# Crea formularios para entrada de datos
entrada_tiempo = ttk.Entry(frame_abajo, validate="key")
# entrada_y = ttk.Entry(frame_derecha, validate="key", validatecommand=validacion_y)
tiempo.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=5, pady=5)
# posicion_y.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=5, pady=5)
entrada_tiempo.pack(side=tk.LEFT,
fill=tk.BOTH,
expand=True,
padx=5,
pady=5)
# entrada_y.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=5, pady=5)
button = ttk.Button(frame_evaluar,
text='Salir',
width=8,
command=Pop_Up.destroy)
button.pack(side=tk.BOTTOM)
button2 = ttk.Button(frame_evaluar,
text='Evaluar',
width=8,
command=Pop_Up.mainloop)
button2.pack(side=tk.BOTTOM)
mpl.show()
#tiempo ingresado por el usuario(temporal)
time_usuario = 1
# generamiento de la grafica
#generacion de la grafica del tiempo ingresado
time = np.arange(0, time_usuario, 0.01)
x = cord_x(self, time)
y = cord_y(self, time)
#grafica completa del lanzamiento
time_complete = np.arange(0, time_impact(self) + 4, 0.01)
x2 = cord_x(self, time_complete)
y2 = cord_y(self, time_complete)
#generacion del punto de posicion a medir
x3 = cord_x(self, time_usuario)
y3 = cord_y(self, time_usuario)
#estetica de la grafica
mpl.title("Aceleracion")
mpl.xlim(0, alcance_max(self) + self.x0)
mpl.ylim(0, altura_max(self) + self.y0)
mpl.xlabel("-Distancia-")
mpl.ylabel("-Altura-")
#generamiento de las curvas
mpl.plot(self.x0, self.y0, "k-o") #punto pos inicial
mpl.plot(x, y, "y-") #curva del usuario
mpl.plot(x2, y2, "k--") #lanzamiento completo
mpl.plot(x3, y3, "r-o") #punto del usuario
mpl.grid() #cuadriculado
#generacion del vector con origen en el punto de posicion
mpl.plot(x3, y3 - time_impact(self), "g-o")
# inicializa el punto de interseccion del eje Y
tiempo_init_y.configure(state='normal')
tiempo_init_y.delete(0, 'end')
tiempo_init_y.insert(0, time_impact(self))
tiempo_init_y.configure(state='readonly')
def boton_vector_normalf(self):
velocidad = int(self.entrada_Rapidez_inicial.get())
angulo_inicial = int(self.entrada_angulo_inicial.get())
nose = (self.gravedad * int(self.entrada_posicion_y0.get()) /
math.pow(velocidad, 2))
tiempo_maximov1 = (velocidad / self.gravedad) * (
(math.sin(math.radians(angulo_inicial))) + math.sqrt(
math.pow(math.sin(math.radians(angulo_inicial)), 2) +
2 * nose))
tiempo_maximo = tiempo_maximov1
print(tiempo_maximov1)
label = tk.Label(Pop_Up)
label.pack()
# Crea un cuadro que contiene los datos
# Organiza los datos
separador = ttk.Separator(Pop_Up, orient="horizontal")
separador.pack(side=tk.TOP, expand=False, fill=tk.X)
# Tiempo Impacto
def time_impact(self):
t = ((self.velocidad_inicial * sin(self.angulo)) /
(2 * self.gravedad)) + (
(1 / self.gravedad) *
(sqrt(((self.velocidad_inicial * sin(self.angulo))**2) +
(2 * self.y0 * self.gravedad))))
print(t)
return t
# Coordenada X
def cord_x(self, t):
x = self.x0 + ((self.velocidad_inicial * cos(self.angulo)) * t)
return x
# # Coordenada Y
def cord_y(self, t):
y = self.y0 + (((self.velocidad_inicial *
(cos(self.angulo))) * t) - ((self.gravedad / 2) *
(t**2)))
return y
# Altura máxima gráfica
def altura_max(self):
r = self.y0 + (((self.velocidad_inicial * (sin(self.angulo)))**2) /
(self.gravedad))
return r
# Alcance maximo gráfica
def alcance_max(self):
alc = self.x0 + ((self.velocidad_inicial * sin(2 * self.angulo)) / (self.gravedad)) + \
((self.velocidad_inicial * cos(self.angulo)) /
(self.gravedad)) * sqrt(
((self.velocidad_inicial * sin(self.angulo)) ** 2) + 2 * self.y0 * self.gravedad)
return alc
time_usuario = 1 # Tiempo ingresado(arreglar)
# Grafica del tiempo ingresado
time = np.arange(0, time_usuario, 0.01)
x = cord_x(self, time)
y = cord_y(self, time)
# Grafica completa lanzamiento
time_complete = np.arange(0, time_impact(self) + 4, 0.01)
x2 = cord_x(self, time_complete)
y2 = cord_y(self, time_complete)
# Punto de posicion a medir
x3 = cord_x(self, time_usuario)
y3 = cord_y(self, time_usuario)
# Detalles gráfica
mpl.title("Aceleracion normal y tangencial")
mpl.xlim(0, alcance_max(self) + self.x0)
mpl.ylim(0, altura_max(self) + self.y0)
mpl.xlabel("Distancia")
mpl.ylabel("Altura")
# Generación curvas
mpl.plot(self.x0, self.y0, "k-o") # Posición inicial
mpl.plot(x, y, "y-") # Curva
mpl.plot(x2, y2, "k--") # Lanzamiento
# mpl.plot(x3, y3, "r-o") # Punto ingresado #Punto rojo de altura maxima
mpl.grid() # Cuadriculacion del grafico
# Generación de las flechas para aceleración normal y tangencial
# >>>>Genera bien las flechas y texto, pero tira un warning. Falta arreglar<<<<
ax = mpl.axes()
ax1 = mpl.axes()
ax.text(15.4, 10.8, 'an', fontsize=9) # Texto aceleracion normal
ax.arrow(x3, y3, 0, -4, head_width=0.5, head_length=1, fc='k',
ec='k') # Flecha de aceleracion normal
ax.text(18.7, 13.7, 'at', fontsize=9) # Texto aceleracion tangencial
ax1.arrow(x3, y3, 5, 0, head_width=0.5, head_length=1, fc='k',
ec='k') # Flecha de aceleracion tangencial
# Muestra el grafico
mpl.plot()
mpl.show()
pass
data.head()
data['title'] = [t[0:-7] for t in data.title]
data.head()
data[['score', 'runtime', 'year', 'votes']].describe()
print len(data[data.runtime == 0])
data.runtime[data.runtime==0] = np.nan
data.runtime.describe()
plt.hist(data.year, bins=np.arange(1950, 2013), color='#cccccc')
plt.xlabel("Release Year")
remove_border()
# Received following message:
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# AttributeError: 'module'object has not attribute 'hist'
# AND
# AttributeError: 'module'object has not attribute 'xlabel'
plt.hist(data.score, bins=20, color='#cccccc')
plt.xlabel("IMDB rating")
remove_border()
# Again, I'm receiving AttributeError messages. Is there an issue with the matplotlib that is not allowing me to produce a histogram?
plt.scatter(data.year, data.score, lw=0, alpha=.08, color='k')
plt.xlabel("Year")
def merlin ( dataset , pos1 , pos2 , act_fun , sov_fun ) :
print("Dataset Given" , dataset.head())
x = dataset.iloc[:, -pos1].values
y = dataset.iloc[:, -pos2].values
print("x \n" , x )
print("y \n" , y )
x = x.reshape(-1, 1)
y = y.reshape(-1, 1)
# Test/Trin Split with shuffle OFF
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=5, shuffle=False)
#datset plotting module
plt.scatter(x_train, y_train, color='black')
plt.plot(x_test, y_test, color='black')
plt.title('Full Data')
plt.xlabel('Days From 1st Case')
plt.ylabel('Cases')
plt.show()
# creating a score dataset
cnames = ['Accuracy', 'Size', 'alpha','Activation_Function','Solver']
acc_matrix = pd.DataFrame(columns=cnames)
print(acc_matrix.head())
acc_lst = []
i_lst = []
nr_list = []
fun1=[]
fun2=[]
iterate_list = [0.0000000001, 0.0000000002, 0.0000000003, 0.0000000004, 0.0000000005, 0.0000000006, 0.0000000007,
0.0000000008, 0.0000000009,
0.000000001, 0.000000002, 0.000000003, 0.000000004, 0.000000005, 0.000000006, 0.000000007,
0.000000008, 0.000000009,
0.00000001, 0.00000002, 0.00000003, 0.00000004, 0.00000005, 0.00000006, 0.00000007, 0.00000008,
0.00000009,
0.0000001, 0.0000002, 0.0000003, 0.0000004, 0.0000005, 0.0000006, 0.0000007, 0.0000008, 0.0000009,
0.000001, 0.000002, 0.000003, 0.000004, 0.000005, 0.000006, 0.000007, 0.000008, 0.000009,
0.00001, 0.00002, 0.00003, 0.00004, 0.00005, 0.00006, 0.00007, 0.00008, 0.00009,
0.0001, 0.0002, 0.0003, 0.0004, 0.0005, 0.0006, 0.0007, 0.0008, 0.0009,
0.001, 0.002, 0.003, 0.004, 0.005, 0.006, 0.007, 0.008, 0.009,
0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09
]
# importing the nural net
from sklearn.neural_network import MLPRegressor
from sklearn.metrics import r2_score
# model Testing Module
for nr in range(100, 110, 10):
print("Nural Size = ", nr)
for i in iterate_list:
mlp = MLPRegressor(activation=act_fun, alpha=i, batch_size='auto', beta_1=0.9,
beta_2=0.999, early_stopping=False, epsilon=1e-08,
hidden_layer_sizes=(nr), learning_rate='constant', max_iter=90000000, momentum=0.9,
n_iter_no_change=10, nesterovs_momentum=True, power_t=0.5,
random_state=5, shuffle=False, solver=sov_fun, tol=0.0001,
validation_fraction=0.1, verbose=False, warm_start=True )
mlp.fit(x_train, y_train.ravel())
predict_test = mlp.predict(x_test)
scr = r2_score(y_test, predict_test)
acc_lst.append(scr)
i_lst.append(i)
nr_list.append(nr)
fun1.append(act_fun)
fun2.append(sov_fun)
print(" i = ", i, "Score = ", scr)
print("Training Complete")
print()
acc_matrix['Accuracy'] = acc_lst
acc_matrix['Size'] = nr_list
acc_matrix['alpha'] = i_lst
acc_matrix['Activation_Function'] = fun1
acc_matrix['Solver'] = fun2
acc_matrix.reset_index()
print(acc_matrix.head())
for i in acc_matrix.index:
if acc_matrix['Accuracy'][i] == max(acc_matrix['Accuracy']):
print("Best Parameters For The Model Is\n")
print("Accuracy ", acc_matrix["Accuracy"][i])
print("Nural Size ", acc_matrix['Size'][i])
print("aplha =", acc_matrix['alpha'][i])
print("Activation Function =", acc_matrix['Activation_Function'][i])
print("Solver =", acc_matrix['Solver'][i])
lr_b = 0
lr_w = 0
# Iterations
for i in range(iteration):
b_grad = 0.0
w_grad = 0.0
for n in range(len(x_data)):
b_grad = b_grad - 2.0 * (y_data[n] - b - w * x_data[n]) * 1.0
w_grad = w_grad - 2.0 * (y_data[n] - b - w * x_data[n]) * x_data[n]
lr_b = lr_b + b_grad**2
lr_w = lr_w + w_grad**2
# Update parameters
b = b - lr / np.sqrt(lr_b) * b_grad
w = w - lr / np.sqrt(lr_w) * w_grad
# Store parameters for plotting
b_history.append(b)
w_history.append(w)
#plot the figure
plt.contourf(x, y, z, 50, alpha=0.5, cmap=plt.get_cmap('jet'))
plt.plot([-188.4], [2.67], 'x', ms=12, markeredgewidth=3, color='orange')
plt.plot(b_history, w_history, 'o-', ms=3, lw=1.5, color='black')
plt.xlim(-200, -100)
plt.ylim(-5, 5)
plt.xlabel(r'$b$', fontsize=16)
plt.ylabel(r'$w$', fontsize=16)
plt.show()
#total number of missing values in dataframe
loan_file.isnull().sum(axis=0)
# In[7]:
loan_file['LoanAmount'].mean()
# In[ ]:
# In[8]:
#visualization of distribution
#lets plot the loan amount and income
loan_file['ApplicantIncome'].hist(bins=50)
plt.title('ApplicantIncome Analysis')
plt.xlabel('Amount')
# In[9]:
#boxplot to understand the destribution
loan_file.boxplot(['ApplicantIncome'])
plt.show()
'''it shows there are too many outliers present in this columns. it shows the income disparity'''
# In[10]:
#income check on the basis of education level
loan_file.boxplot(['ApplicantIncome'], by=['Education'])
plt.show()
# In[11]:
t = pickle.load(pickle_file)
v = pickle.load(pickle_file)
print t
print v
initialize(v, s, t, dt, n)
calculate(v, s, t, dt, n)
store(v, t, n)
#plot
plt.figure(1)
plt.subplot(211)
plt.plot(t, v,"g-", linewidth=2.0)
plt.scatter(t, v)
plt.title('The Velocity of a Free Falling Object')
plt.xlabel('Time($t$)', fontsize=14)
plt.ylabel('Velocity($m/s$)', fontsize=14)
plt.text(3,-60,r'$g = 9.8 m/s^2$', fontsize=16)
plt.grid(True)
plt.subplot(212)
plt.plot(t, s,"g-", linewidth=2.0)
plt.scatter(t, s)
plt.title('The Displacement of a Free Falling Object')
plt.xlabel('Time($t$)', fontsize=14)
plt.ylabel('Displacement($m$)', fontsize=14)
plt.text(3,-300,r'$g = 9.8 m/s^2$', fontsize=16)
plt.grid(True)
plt.show()
plt.savefig("ex1.jpg")
line = line.strip()
A, B, C, D, E, F = line.split(',')
if (A == "ConcurrentHashMap" and E == "write"):
sum1 += int(F)
count += 1
if (A == "SynchronizedMap" and E == "write"):
sum2 += int(F)
count2 += 1
if (count == 200):
x.append(B)
y.append(sum1 / 1000)
count = 0
sum1 = 0
if (count2 == 200):
x1.append(B)
y1.append(sum2 / 1000)
count2 = 0
sum2 = 0
dataset8.close()
plt.xlabel('Threads')
plt.ylabel('Tempo Médio (ns)')
line_up, = plt.plot(x, y, label='ConcurrentHashMap')
line_down, = plt.plot(x1, y1, label='Collections.synchronizedMap')
plt.legend([line_up, line_down],
['ConcurrentHashMap', 'Collections.synchronizedMap'])
plt.title('Grafico para operação de escrita, usando 0.2 de carga na operação')
plt.show()
rorder = {}
rorder_len = 0
for k, v in sorted(res, key = lambda x: x[1], reverse=True):
rorder[k] = rorder_len + 1
rorder_len += 1
ntop = int(threshold_ratio * rorder_len)
output = open(outfile, 'w')
nhit = 0
ntot = 0
output.write('EventId,RankOrder,Class\n')
for k, tmp in res:
if rorder[k] <= ntop:
lb = 's'
nhit += 1
else:
lb = 'b'
output.write('%s,%d,%s\n' % (k, len(rorder) + 1 - rorder[k], lb))
ntot += 1
output.close()
feature_names = list(data_test[1:].columns)
for feature in feature_names:
tmp = data_train.DER_mass_MMC[data_train.DER_mass_MMC != -999.0]
tmp.hist(bins=100)
mplt.xlabel(feature)
mplt.show()
import matplotlib as plt
from 数据分析处理 import price, area
linear = LinearRegression()
area = np.array(area).reshape(-1, 1)
price = np.array(price).reshape(-1, 1)
# 训练模型
model = linear.fit(area, price)
# 打印截距和回归系数
print(model.intercept_, model.coef_)
# 线性回归可视化(数据拟合)
linear_p = model.predict(area)
plt.figure(figsize=(12, 6))
plt.scatter(area, price)
plt.plot(area, linear_p, 'red')
plt.xlabel("area")
plt.ylabel("price")
plt.show()
# 使用train_test_split进行交叉验证
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(X,
y,
test_size=0.2,
random_state=12)
print(x_train.shape, y_train.shape)
print(x_test.shape, y_test.shape)
# 模型训练
linear = LinearRegression()
model = linear.fit(x_train, y_train)
# -*- coding: utf-8 -*-
"""
Created on Mon Jan 23 11:07:06 2017
@author: Paige
"""
import matplotlib as plt
import numpy as np
x = np.linspace(-10, 10, 400)
cos = np.cos(x)
sin = np.sin(x)
plt.plot(x, cos, "r", label="cos(x)") # r for red line
plt.plot(x, sin, "b--", label="sin(x)") # b-- for blue dashed line
# colors include red(r), green(g), yellow(y), blue(b), cyan(c),
# magenta(m), black(k), white(w)
# line styles include solid line("-"), dashed line("--"),
# solid line("-"), square("s"), dots("o"), smaller dots(".")
plt.xlim(-10, 10)
plt.legend()
plt.xlabel("x")
plt.title("Trigonometric Functions")
plt.ylabel("cos(x) or sin(x)")
# plt.savefig("1-23-2017.png")
plt.show()
def print_statements(soln, i):
if i > 0: # Solution found
print("Number of function calls: %d" % (2 + i))
print("A solution is: %f" % (soln))
else:
print("Solution not found!")
solution, no_iter, vals, objectfs = n_m(0.8, 1e-1)
print_statements(solution, no_iter)
print("\n\n")
plt.scatter(vals, objectfs)
plt.xlabel("X")
plt.ylabel("f(X)")
plt.title("Newton's method")
plt.show()
x0 = 0.3
x1 = 0.8
solution, no_iter, ob, vals = secant_mth(x0, x1, eps=1e-1)
print_statements(solution, no_iter)
plt.scatter(vals, ob)
plt.xlabel("X")
plt.ylabel("f(X)")
plt.title("Secant method")
plt.show()
cos += ((-1)**i)*x**(2*i)/math.factorial(2*i)
return cos
x0 = time.clock()
for i in range(1, 100):
x = tcos(1, i)
x = time.clock()
y = numpy.cos(1)
y = time.clock()
print 'tcos :' + str(x - x0) + ' numpy: ' + str(y - x)
x0 = y
t = numpy.arange(0.0, 1.1, 0.01)
plt.plot(t, tcos(2*pi*t, 10))
plt.plot(t, tcos(2*pi*t, 9))
plt.plot(t, numpy.cos(t*2*pi))
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)
plt.show()
print '\nExercise 1.3.2:\n'
print ' As you can see in the plot, the 10th order gives a good approximation of the cos-function.'
print '\nExercise 1.3.3:\n'
print ' My method does not determine any significant difference betwwen the two implementations.'
print ' I would expect a better performance of the numpy implementation.'
def pos_plot(isnap, irun, iPartType, lim):
'Function plots position plots of particles for three projections'
#... Time
time = isnap*0.05
#...Tag for Saving
tag_list = ['Gas', 'DM', '?', '', 'Stars', '' ]
tag_type = tag_list[iPartType]
#...Load File
f = h5py.File(base + '/snapshot_' + str(isnap).zfill(3) +'.hdf5')
#...Load Stellar Data
xyz = np.array(f['PartType'+str(iPartType)+'/Coordinates'])
############################################## PLOT ########################################################
#...Some Parameters:
cbar = 'magma'
nbins = 100
cmin,cmax = 7.0, 11.0 #0, 1.5e4
mperp = 800
############# Calculate counts
counts1, xedges, yedges, img = plt.hist2d(xyz[:,0],xyz[:,1],bins=nbins,range=[[-lim,lim],[-lim,lim]])
counts2, xedges, yedges, img = plt.hist2d(xyz[:,0],xyz[:,2],bins=nbins,range=[[-lim,lim],[-lim,lim]])
counts3, xedges, yedges, img = plt.hist2d(xyz[:,1],xyz[:,2],bins=nbins,range=[[-lim,lim],[-lim,lim]])
#...Set up figure box:
plt.style.use('dark_background')
fig = plt.figure(figsize = [20,6])
######################### Plot xy
ax = fig.add_subplot(1, 3, 1)
#counts, xedges, yedges, img = plt.hist2d(xyz[:,0],xyz[:,1],bins=nbins)
counts1 = np.log(counts1*mperp)
plt.imshow(counts1, origin='lower',extent=[-lim, lim, -lim, lim], cmap=cbar, vmin=cmin, vmax=cmax)
ax.axis([-lim,lim,-lim,lim])
plt.axis('equal')
#plt.xlim(box_size)
#plt.ylim(box_size)
plt.xlabel('x (kpc)')
plt.ylabel('y (kpc)')
plt.title('xy')
#plt.colorbar()
ax.text(-lim, lim, str(time)+'Gyr', fontsize=20)
######################### Plot xz
ax = fig.add_subplot(1, 3, 2)
#plt.hist2d(xyz[:,0],xyz[:,2],cmap=cbar,bins=nbins,weights=mass,vmin=cmin,vmax=cmax)
#counts, xedges, yedges, img = plt.hist2d(xyz[:,0],xyz[:,2],bins=nbins)
counts2 = np.log(counts2*mperp)
plt.imshow(counts2, origin='lower',extent=[-lim, lim, -lim, lim], cmap=cbar, vmin=cmin, vmax=cmax)
ax.axis([-lim,lim,-lim,lim])
plt.axis('equal')
#plt.xlim(box_size)
#plt.ylim(box_size)
plt.xlabel('x (kpc)')
plt.ylabel('z (kpc)')
plt.title('xz')
#plt.colorbar()
#ax.text(-lim+1, lim+.5, str(time)+'Gyr', fontsize=20)
######################### Plot yz
ax = fig.add_subplot(1, 3, 3)
#plt.hist2d(xyz[:,1],xyz[:,2],cmap=cbar,bins=nbins,weights=mass,vmin=cmin,vmax=cmax)
#counts, xedges, yedges, img = plt.hist2d(xyz[:,1],xyz[:,2],bins=nbins)
counts3 = np.log(counts3*mperp)
plt.imshow(counts3, origin='lower',extent=[-lim, lim, -lim, lim], cmap=cbar, vmax=cmax)
ax.axis([-lim,lim,-lim,lim])
plt.axis('equal')
#plt.xlim(box_size)
#plt.ylim(box_size)
plt.xlabel('y (kpc)')
plt.ylabel('z (kpc)')
plt.title('yz')
cb = plt.colorbar()
cb.set_label('log(Msun/bin)',fontsize = 20)
#ax.text(-lim+1, lim+.5, str(time)+'Gyr', fontsize=20)
################################################# SAVING ########################################################
save_fig_file = '/data8/data/mercadf1/output/Pegasus/high_res/aruns/run_'+ str(irun)+'/Plots/pos_plots/'+tag_type+'_2Dhist_run'+str(irun)+'_snap'+str(isnap)+'.png'
#save_fig_file = '/data25/rouge/gonzaa11/francisco/outputs/runmed'+str(irun)+'/Plots/pos_plots/'+tag_type+'_pos_run'+str(irun)+'_snap'+str(isnap)+'.png'
#...Report saving:
print "Saving : "
print str(save_fig_file)
#...Save Figure:
plt.savefig(save_fig_file)
return 'Snapshot '+str(isnap)+' complete'
def linear_regression(x_data, y, tag=""):
# Splitting the dataset into the Training set and Test set
# Here I am using the train_test_split function present in the SKlearn library.
# This function splits the data into training testing and validation datasets as shown below.
# we can specify the percentage of test size compared to the input matrix size.
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x_data,
y,
test_size=0.2,
random_state=0)
# The rows are randomly sorted into the groups to form M initial clusters. An exchange algorithm is applied to
# this initial configuration which searches for the rows of data that would produce a maximum decrease in a
# least-squares penalty function.
kmeans = KMeans(n_clusters=M, random_state=0).fit(x_train)
Mu = kmeans.cluster_centers_
def big_sigma_matrix(Data):
"""
Summation of all the variance values along the diagonal. This is also called the co-variance matter.
:param Data: This will be the training data that we are using to generate the covariance matrix
:return: Covariance matrix
"""
BigSigma = np.zeros((Data.shape[1], Data.shape[1]))
DataT = np.transpose(Data)
for i in range(0, len(DataT)):
BigSigma[i][i] = np.var(DataT[i])
BigSigma = np.dot(200, BigSigma)
return BigSigma
def phi_matrix(Data, MuMatrix, BigSigma):
"""
This will generate the design matrix phi
:param Data: Training/Testing/Validation sets
:param MuMatrix: Matrix with centroid values for the clusters
:param BigSigma: Covariance matrix
:return: Design matrix Phi
"""
phi = np.zeros((int(len(Data)), len(MuMatrix)))
BigSigInv = np.linalg.inv(BigSigma)
for C in range(0, len(MuMatrix)):
for R in range(0, int(len(Data))):
sub = np.subtract(Data.iloc[R], MuMatrix[C])
sub_1 = np.dot(BigSigInv, np.transpose(sub))
phi[R][C] = np.math.exp(-0.5 * np.dot(sub, sub_1))
return phi
def closed_form_weights(phi_matrix, lambda_value, targets):
"""
Calculate the weights (W/theta Matrix)
:param phi_matrix: Design matrix Phi
:param lambda_value: term that governs the relative importance of the regularization term
:param targets: Target vector
:return: Weight matrix W/theta
"""
lamba_identity = np.identity(M)
for i in range(M):
lamba_identity[i][i] = lambda_value
weight = np.linalg.inv(
np.add(lamba_identity,
np.dot(phi_matrix.transpose(), phi_matrix))).dot(
phi_matrix.transpose().dot(targets))
return weight
def root_mean_squared_error_SGD(data, output):
"""
Method to find the RMS value for SGD method
:param data: Data matrix
:param output: Actual Output matrix retrieved through regression
:return: RMS value
"""
sum = 0.0
for i in range(0, len(output)):
sum = sum + np.math.pow((data[i] - output[i]), 2)
return str(np.math.sqrt(sum / len(output)))
# Generate the big sigma, training/testing/validation design matrices and the weights using the training design
# matrix
big_sigma = big_sigma_matrix(x_data)
training_phi = phi_matrix(x_train, Mu, big_sigma)
testing_phi = phi_matrix(x_test, Mu, big_sigma)
weights_cf = closed_form_weights(training_phi, lambda_value, y_train)
# Choose a random initial weight
initial_weight = np.dot(220, weights_cf)
initial_weight = initial_weight.transpose()
# Iterate over 500 times to find the minima using the gradient descent approach
# To find a local minimum of a function using gradient descent, we take steps proportional to the negative of the
# gradient of the function at the current point.
testing_error = []
for i in range(0, epochs):
delta_error = np.add(
-np.dot(training_phi[i] - np.dot(initial_weight, training_phi[i]),
(training_phi[i])), np.dot(2, initial_weight))
new_weight = -np.dot(alpha, delta_error) + initial_weight
initial_weight = new_weight
# Find the RMS value at each iteration to check the learning of the model. We try to approach the minima which is
# ideally 0. In our case with 500 iterations I was able to reach 0.05-0.06. With higher number of iterations,
# we can decrease the RMS value further.
training_sgd_output_rms = root_mean_squared_error_SGD(
np.dot(new_weight, np.transpose(training_phi)),
training_phi.transpose()[0])
testing_sgd_output_rms = root_mean_squared_error_SGD(
np.dot(new_weight, np.transpose(testing_phi)),
testing_phi.transpose()[0])
testing_error.append(float(testing_sgd_output_rms))
print(testing_error[len(testing_error) - 1])
figure = plt.figure()
plt.plot(np.arange(epochs), testing_error)
plt.suptitle('Error RMS')
plt.xlabel('Number of iterations')
plt.ylabel('Testing RMS error rate')
figure.savefig(tag)
if i%60 == 0 or i%100 == 0 or i == 1 or i == 2 or i == 3:
train_accuracy = accuracy.eval(feed_dict={x: np.array(X_train1).reshape(-1,224*224*3)
,y_: np.array(y_train1).reshape(-1,4),keep_prob: 1})
print('step %d, training accuracy %g' % (i, train_accuracy))
if train_accuracy >0.75 or i%120 == 0 or i == 1 or i == 2 or i == 3:
confusion_mc=sess.run(tf.confusion_matrix( tf.argmax(y_, 1),tf.argmax(y_conv, 1)),
feed_dict = {x: np.array(X_test_cv).reshape(-1,224*224*3),
y_: np.array(y_test_cv).reshape(-1,4),keep_prob: 1})
df_cm = pd.DataFrame(confusion_mc,
index =y_train1.columns, columns = y_train1.columns )
plt.figure()
sns.heatmap(df_cm, annot=True)
plt.ylabel('True label %d ' %i)
plt.xlabel('Predicted label')
plt.show()
print(np.median(sess.run(W_conv1_1)),np.mean(sess.run(W_conv1_1)),np.var(sess.run(W_conv1_1)))
print(np.median(sess.run(W_conv3_2)),np.mean(sess.run(W_conv3_2)),np.var(sess.run(W_conv3_2)))
print(np.median(sess.run(W_fc2)),np.mean(sess.run(W_fc2)),np.var(sess.run(W_fc2)))
print((sess.run(cross_entropy,feed_dict={x: np.array(X_train1).reshape(-1,224*224*3),
y_: np.array(y_train1).reshape(-1,4),keep_prob: 1})))
toc = time.time()
print((toc-tic)/60)
merge = tf.summary.merge_all()
summary = sess.run(merge,feed_dict={x: np.array(X_train1).reshape(-1,224*224*3),
y_:np.array(y_train1).reshape(-1,4),
keep_prob: 1})
if i%100==0:
save_path = saver.save(sess, "C:/Users/woill/.spyder-py3/tmp/model.ckpt")
writer.add_summary(summary, i)
# B) What does the distribution of petal lengths look like?
sns.distplot(iris.Petal_Length)
# C) Is there a correlation between petal length and petal width?
sns.heatmap(iris.corr(), annot=True, cmap='OrRd')
sns.relplot(data=iris, x="Petal_Length", y="Petal_Width")
# D) Would it be reasonable to predict species based on sepal width and sepal length?
iris.head()
sns.relplot(data=iris, x="Sepal_Width", y="Sepal_Length", hue="Species")
plt.title('Species by Septal')
plt.xlabel('Sepal Length')
plt.ylabel('Sepal Width')
# E) Which features would be best used to predict species?
sns.relplot(data=iris, x="Petal_Length", y="Petal_Width", hue="Species")
plt.title('Species by Petal')
plt.xlabel('Petal Length')
plt.ylabel('Petal Width')
sns.pairplot(data=iris, hue='Species')
# 1.) Use seaborn's load_dataset function to load the anscombe data set.
# Use pandas to group the data by the dataset column,
# and calculate summary statistics for each dataset. What do you notice?
if (j < i):
tag1 = keys_tags_pop[i]
tag2 = keys_tags_pop[j]
Count = np.asarray((CrossTab_artistsID_tagID[tag1] > 0)
& (CrossTab_artistsID_tagID[tag2] > 0))
sm = Count.sum()
DistanceMatrix[i, j] = np.exp(-sm)
DistanceMatrix_sym = (DistanceMatrix.T + DistanceMatrix)
Z = linkage(DistanceMatrix_sym, 'ward')
max_d = 50
plt.figure()
plt.title('Hierarchical Clustering Dendrogram')
plt.xlabel('Tags ID')
plt.ylabel('Distance')
dendrogram(
Z,
leaf_rotation=90., # rotates the x axis labels
leaf_font_size=8., # font size for the x axis labels
labels=keys_tags_pop,
color_threshold=max_d,
)
plt.savefig("Dendrogram_1.png", bbox_inches='tight')
plt.show()
clusters = fcluster(Z, max_d, criterion='distance')
#Interpretation
Profile = {}
options_data.loc[option]['PRICE'],
sigma_est=2., #Estimate for implied volatility
it=100)
options_data['IMP_VOL'].loc[option] = imp_vol
futures_data['MATURITY']
#Select column with name MATURITY
options_data.loc[46170]
#Select Data row for index 46170
options_data.loc[46710]['STRIKE']
#Select only value in column STRIKE
plot_data = options_data[options_data['IMP_VOL'] > 0]
maturities = sorted(set(options_data['MATURITY']))
maturities
#Reiterate over all maturities and plot
import matplotlib as plt
#%matplotlib inline
plt.figure(figsize=(8,6))
for maturity in maturities:
data = plot_data[options_data.MATURITY == maturity]
#Select data for this maturity
plt.plot(data['STRIKE'], data['IMP_VOL'], label=maturity.date(), lw=1.5)
plt.plot(datadata['STRIKE'], data['IMP_VOL'], 'r.')
plt.grid(True)
plt.xlabel('strike')
plt.ylabel('implied volatility of volatility')
plt.legend()
plt.show()
def final_decision_plot(df,
figureName,
z_s=10,
z_b=10,
show=False,
block=False,
trafoD_bins=True,
bin_number=15):
"""Plots histogram decision score output of classifier"""
nJets = df['nJ'].tolist()[1]
if trafoD_bins == True:
bins, arg2, arg3 = trafoD_with_error(df)
print(len(bins))
else:
bins = np.linspace(-1, 1, bin_number + 1)
# Initialise plot stuff
plt.ion()
plt.close("all")
fig = plt.figure(figsize=(8.5, 7))
plot_range = (-1, 1)
plot_data = []
plot_weights = []
plot_colors = []
plt.rc('font', weight='bold')
plt.rc('xtick.major', size=5, pad=7)
plt.rc('xtick', labelsize=10)
plt.rcParams["font.weight"] = "bold"
plt.rcParams["axes.labelweight"] = "bold"
plt.rcParams["mathtext.default"] = "regular"
df = setBinCategory(df, bins)
bins = np.linspace(-1, 1, len(bins))
decision_value_list = df['bin_scaled'].tolist()
post_fit_weight_list = df['post_fit_weight'].tolist()
sample_list = df['sample'].tolist()
# Get list of hists.
for t in class_names_grouped[::-1]:
class_names = class_names_map[t]
class_decision_vals = []
plot_weight_vals = []
for c in class_names:
for x in range(0, len(decision_value_list)):
if sample_list[x] == c:
class_decision_vals.append(decision_value_list[x])
plot_weight_vals.append(post_fit_weight_list[x])
plot_data.append(class_decision_vals)
plot_weights.append(plot_weight_vals)
plot_colors.append(colour_map[t])
# Plot.
if nJets == 2:
multiplier = 20
elif nJets == 3:
multiplier = 100
plt.plot([], [],
color='#FF0000',
label=r'VH $\rightarrow$ Vbb x ' + str(multiplier))
plt.hist(plot_data,
bins=bins,
weights=plot_weights,
range=plot_range,
rwidth=1,
color=plot_colors,
label=legend_names[::-1],
stacked=True,
edgecolor='none')
df_sig = df.loc[df['Class'] == 1]
plt.hist(df_sig['bin_scaled'].tolist(),
bins=bins,
weights=(df_sig['post_fit_weight'] * multiplier).tolist(),
range=plot_range,
rwidth=1,
histtype='step',
linewidth=2,
color='#FF0000',
edgecolor='#FF0000')
x1, x2, y1, y2 = plt.axis()
plt.yscale('log', nonposy='clip')
plt.axis((x1, x2, y1, y2 * 1.2))
axes = plt.gca()
axes.set_ylim([5, 135000])
axes.set_xlim([-1, 1])
x = [-1, -0.8, -0.6, -0.4, -0.2, 0, 0.2, 0.4, 0.6, 0.8, 1]
plt.xticks(x, x, fontweight='normal', fontsize=20)
y = [r"10", r"10$^{2}$", r"10$^{3}$", r"10$^{4}$", r"10$^{5}$"]
yi = [10, 100, 1000, 10000, 100000]
plt.yticks(yi, y, fontweight='normal', fontsize=20)
axes.yaxis.set_ticks_position('both')
axes.yaxis.set_tick_params(which='major',
direction='in',
length=10,
width=1)
axes.yaxis.set_tick_params(which='minor',
direction='in',
length=5,
width=1)
axes.xaxis.set_ticks_position('both')
axes.xaxis.set_tick_params(which='major',
direction='in',
length=10,
width=1)
axes.xaxis.set_tick_params(which='minor',
direction='in',
length=5,
width=1)
axes.xaxis.set_minor_locator(AutoMinorLocator(4))
handles, labels = axes.get_legend_handles_labels()
#Weird hack thing to get legend entries in correct order
handles = handles[::-1]
handles = handles + handles
handles = handles[1:12]
plt.legend(loc='upper right',
ncol=1,
prop={'size': 12},
frameon=False,
handles=handles)
plt.ylabel("Events", fontsize=20, fontweight='normal')
axes.yaxis.set_label_coords(-0.07, 0.93)
plt.xlabel(r"BDT$_{VH}$ output", fontsize=20, fontweight='normal')
axes.xaxis.set_label_coords(0.89, -0.07)
an1 = axes.annotate("ATLAS Internal",
xy=(0.05, 0.91),
xycoords=axes.transAxes,
fontstyle='italic',
fontsize=16)
offset_from = OffsetFrom(an1, (0, -1.4))
an2 = axes.annotate(r'$\sqrt{s}$' + " = 13 TeV , 36.1 fb$^{-1}$",
xy=(0.05, 0.91),
xycoords=axes.transAxes,
textcoords=offset_from,
fontweight='normal',
fontsize=12)
offset_from = OffsetFrom(an2, (0, -1.4))
an3 = axes.annotate("1 lepton, " + str(nJets) + " jets, 2 b-tags",
xy=(0.05, 0.91),
xycoords=axes.transAxes,
textcoords=offset_from,
fontstyle='italic',
fontsize=12)
offset_from = OffsetFrom(an3, (0, -1.6))
an4 = axes.annotate("p$^V_T \geq$ 150 GeV",
xy=(0.05, 0.91),
xycoords=axes.transAxes,
textcoords=offset_from,
fontstyle='italic',
fontsize=12)
fig = plt.gcf()
#fig.set_size_inches(10, 4)
plt.savefig(figureName, bbox_inches='tight',
dpi=300) # should before plt.show method
plt.show(block=block)
return fig, axes
# Change the axis units font
plt.setp(ax.get_ymajorticklabels(), fontsize=18)
plt.setp(ax.get_xmajorticklabels(), fontsize=18)
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
# Turn on the plot grid and set appropriate linestyle and color
ax.grid(True, linestyle=':', color='0.75')
ax.set_axisbelow(True)
# Define the X and Y axis labels
plt.xlabel('Impact Velocity (m/s)', fontsize=22, weight='bold', labelpad=5)
plt.ylabel('Drop Height (m)', fontsize=22, weight='bold', labelpad=10)
plt.plot(impact_velocity,
height,
linewidth=2,
linestyle='-',
label=r'Height (m)')
# uncomment below and set limits if needed
# plt.xlim(0,5)
# plt.ylim(0,10)
# Adjust the page layout filling the page using the new tight_layout command
plt.tight_layout(pad=0.5)
# save the figure as a high-res pdf in the current folder
import pandas as pd
import matplotlib as plt
import seaborn as sns
flight_filepath = "../input/flight_delays.csv"
flight_data = pd.read_csv(flight_filepath, index_col="Month")
# Bar
plt.figure(figsize=(10, 6))
plt.title("Average Arrival Delay for Spirit Airlines Flights, by Month")
sns.barplot(x=flight_data.index, y=flight_data['NK'])
plt.ylabel("Arrival delay (in minutes)")
plt.figure(figsize=(14, 7))
plt.figure(figsize=(14, 7))
sns.heatmap(data=flight_data, annot=True)
plt.xlabel("Airline")
import numpy
import matplotlib as plt
### Displace Random Weight DIMER affect on Saddle Force Calls ###
SADDLE_E = [[
.299, .324, .325, .326, .337, .348, .357, .358, .359, .360, .368, .370,
.389, .390, .391, 1.276, 1.278, 2.076, 2.156, 2.484
]]
x = [0, 0.3, 0.6, 0.9]
plt.gca().set_color_cycle(['red', 'green', 'blue', 'yellow', 'black'])
plt.plot(x, SADDLE1)
plt.scatter(x, SADDLE1)
plt.scatter(x, Saddle2)
plt.scatter(x, Saddle3)
plt.scatter(x, Saddle4)
plt.scatter(x, Saddle5)
plt.plot(x, Saddle2)
plt.plot(x, Saddle3)
plt.plot(x, Saddle4)
plt.plot(x, Saddle5)
plt.legend([
'Saddle 1 (0.588)', 'Saddle 2 (0.607)', 'Saddle 3 (0.983)',
'Saddle 4 (.985)', 'Saddle 5 (0.986)'
],
loc='lower left')
plt.xlabel('Probability of Displacing Randomly')
plt.ylabel('Avg. Force Calls', color='b')
#plt.show()
savefig('Dimer_Displace_Random_Weight.png')
# In[29]:
y = data['Purchase']
# In[35]:
from sklearn.linear_model import Ridge
ridge_regressor = Ridge(alpha=1e-10)
ridge_regressor.fit(datax, y)
X_grid = np.arange(min(datax), max(datax), 0.01)
X_grid = X_grid.reshape((len(X_grid), 1))
plt.scatter(datax, y, color='red')
plt.plot(X_grid, regressor.predict(X_grid), color='blue')
plt.title('Truth or Bluff (Random Forest Regression)')
plt.xlabel('Position level')
plt.ylabel('Salary')
plt.show()
# In[38]:
tdata = pd.read_csv("E:\\assignment\\ass 3 analytic vidhya\\test.csv")
# In[39]:
tdata.isnull().values.any()
# In[40]:
features_with_na = [
features for features in tdata.columns
