def __init__(self, fsize, axrect, figure, axes): """Initialize PlotMPL class""" import matplotlib.figure self._plot_valid = True if figure is None: if not iterable(fsize): fsize = (fsize, fsize) self.figure = matplotlib.figure.Figure(figsize=fsize, frameon=True) else: figure.set_size_inches(fsize) self.figure = figure if axes is None: self._create_axes(axrect) else: axes.cla() axes.set_position(axrect) self.axes = axes canvas_classes = self._set_canvas() self.canvas = canvas_classes[0](self.figure) if len(canvas_classes) > 1: self.manager = canvas_classes[1](self.canvas, 1) for which in ["major", "minor"]: for axis in "xy": self.axes.tick_params(which=which, axis=axis, direction="in", top=True, right=True)
def setup_viz(state): """Setup visualization.""" import matplotlib import matplotlib.figure import matplotlib.backends.backend_tkagg import Tkinter import threading viz = {} # Initialise Tk ... figure = matplotlib.figure.Figure() figure.set_size_inches((8, 6)) viz['axes1'] = figure.add_subplot(311) viz['axes2'] = figure.add_subplot(312) viz['axes3'] = figure.add_subplot(313) viz['tk'] = Tkinter.Tk() viz['canvas'] = matplotlib.backends.backend_tkagg.FigureCanvasTkAgg( figure, master=viz['tk']) viz['canvas'].get_tk_widget().pack(expand=True, fill=Tkinter.BOTH) return viz
def __init__(self, fsize, axrect, figure, axes): """Initialize PlotMPL class""" import matplotlib.figure self._plot_valid = True if figure is None: if not is_sequence(fsize): fsize = (fsize, fsize) self.figure = matplotlib.figure.Figure(figsize=fsize, frameon=True) else: figure.set_size_inches(fsize) self.figure = figure if axes is None: self._create_axes(axrect) else: axes.cla() axes.set_position(axrect) self.axes = axes self.interactivity = get_interactivity() figure_canvas, figure_manager = self._get_canvas_classes() self.canvas = figure_canvas(self.figure) if figure_manager is not None: self.manager = figure_manager(self.canvas, 1) self.axes.tick_params(which="both", axis="both", direction="in", top=True, right=True)
def changeSize(figure, factor): global canvas, mplCanvas, interior, interior_id, frame, cwid oldSize = figure.get_size_inches() print("old size is", oldSize) figure.set_size_inches([factor * s for s in oldSize]) wi, hi = [i * figure.dpi for i in figure.get_size_inches()] print("new size is", figure.get_size_inches()) print("new size pixels: ", wi, hi) mplCanvas.config(width=wi, height=hi) canvas.itemconfigure(cwid, width=wi, height=hi) canvas.config(scrollregion=canvas.bbox(Tkconstants.ALL), width=200, height=200) #figure.tight_layout() # matplotlib > 1.1.1 #figure.subplots_adjust(left=0.2, bottom=0.15, top=0.86) figure.canvas.draw()
def __init__(self, figure = None, left = 0.2, bottom = 0.2, width = 0.6, height = 0.6, axes = None, polar = None, autoscaling = None): """FIGURE is the matplotlib.figure.Figure instance where to act on. AXES is optionally an existing axes instance. If AXES is not given, a new axes instance will be created, either a cartesian, or a polar if POLAR is True. Autoscaling will be turned on by default, if not overridded by AUTOSCALING. If FIGURE is not given, it will be created and be initialised to be held and of size (1, 1) inches.""" if autoscaling is None: autoscaling = True if figure is None: figure = matplotlib.figure.Figure(frameon = False) figure.hold(True) figure.set_size_inches(1, 1) # Initialise attributes ... self.layers = [] self.drawn_layers = [] self.needs_reset = False self.figure = figure if axes is None: # Create a new axes instance. self.axes = self.figure.add_axes( (left, bottom, width, height), polar = polar) else: # Take over the axes. self.axes = axes # Initialise the title etc. to some values. self.title = None self.xlabel = None self.ylabel = None # Turn autoscaling on. self.set_autoscale_on(autoscaling)
def __init__(self, fsize, axrect, figure, axes): """Initialize PlotMPL class""" import matplotlib.figure from ._mpl_imports import FigureCanvasAgg self._plot_valid = True if figure is None: self.figure = matplotlib.figure.Figure(figsize=fsize, frameon=True) else: figure.set_size_inches(fsize) self.figure = figure if axes is None: self.axes = self.figure.add_axes(axrect) else: axes.cla() axes.set_position(axrect) self.axes = axes self.canvas = FigureCanvasAgg(self.figure) for which in ['major', 'minor']: for axis in 'xy': self.axes.tick_params(which=which, axis=axis, direction='in', top=True, right=True)
def drawSVMParaFirgure(xList, yList): ''' #here's our data to plot, all normal Python lists x = [1, 2, 3, 4, 5] y = [0.1, 0.2, 0.3, 0.4, 0.5] intensity = [5, 10, 15, 20, 25,30, 35, 40, 45, 50,55, 60, 65, 70, 75,80, 85, 90, 95, 100,105, .01, 115, 120, 125] #setup the 2D grid with Numpy x, y = np.meshgrid(x, y) #convert intensity (list of lists) to a numpy array for plotting intensity = np.array(intensity).reshape((5, 5)) print(intensity) #now just plug the data into pcolormesh, it's that easy! plt.pcolormesh(x, y, intensity) plt.colorbar() #need a colorbar to show the intensity scale plt.show() #boom ''' gamma = 1e-9*4.5 gammaList = [ gamma*(10**powE) for powE in range(10)] C = 0.00001 CList = [ C*(10**powE) for powE in range(10)] print(gammaList) print(CList) resultList = [] scoreList = [] decision_function = 'ovr' for C in CList: for gamma in gammaList: clf_rbf = svm.SVC(decision_function_shape=decision_function, C=C, kernel='rbf', gamma=gamma) #cross validation #print("rbf cross validation") score_rbf = cross_validation.cross_val_score(clf_rbf, xList, yList, cv=3) mean = score_rbf.mean() resultList.append({'C':C, 'gamme':gamma, 'score':mean}) scoreList.append(mean) scoreList = np.array(scoreList) maxScore = 0 maxResult = [] for result in resultList: score = result['score'] if maxScore < score: maxScore = score maxResult = result print (maxScore, maxResult) x = gammaList y = CList x = range(len(gammaList)+1) y = range(len(CList)+1) intensity = scoreList.reshape((len(gammaList), len(CList))) #print(x) #print(y) #print(intensity) #f1 = scoreList.reshape((6, 6)) #setup the 2D grid with Numpy x, y = np.meshgrid(x, y) plt.pcolormesh(x, y, intensity) plt.colorbar() #need a colorbar to show the intensity scale #plt.show() #boom fig = matplotlib.pyplot.gcf() fig.set_size_inches(10.5, 8.5) fig.savefig("SVM_C_gamma.png", dpi=100)
def plot_path(path, path2=None, path3=None, title="", reward=None, x_label=None, y_label=None, waypoint_centers=(), highlight_waypoint_index=None, radii=(0, 0), linewidth=3): assert len(path[0]) == 2 if reward is not None: title += " | Total Reward: {0:.2f}".format(reward) title += " | Steps: " + str(len(path) - 1) # get x's and y's x = [s[0] for s in path] y = [s[1] for s in path] # color map variables to configure a gradient along the trajectory color_num_scale = np.linspace(0, len(path), len(path)) cmap = truncate_colormap(plt.get_cmap('gnuplot2_r'), minval=.1, maxval=.9) norm = plt.Normalize(0, len(path)) # draw trajectory line_collection = make_line_collection(x, y, color_num_scale, cmap=cmap, norm=norm, linewidth=linewidth) line_collection2 = None line_collection3 = None cmap2 = None norm2 = None if path2: # get x's and y's x2 = [s[0] for s in path2] y2 = [s[1] for s in path2] # color map variables to configure a gradient along the trajectory color_num_scale2 = np.linspace(0, len(path2), len(path2)) cmap2 = truncate_colormap(plt.get_cmap('cubehelix_r'), minval=.1, maxval=.8) norm2 = plt.Normalize(0, len(path2)) # draw trajectory line_collection2 = make_line_collection(x2, y2, color_num_scale2, cmap=cmap2, norm=norm2, linewidth=linewidth) x += x2 y += y2 figure, (axis0, axis1, axis2) = plt.subplots(1, 3, gridspec_kw={ 'width_ratios': [24, 1, 1]}) # type: (matplotlib.figure.Figure, (matplotlib.axes.Axes, matplotlib.axes.Axes)) cb2 = matplotlib.colorbar.ColorbarBase(axis2, cmap=cmap2, norm=norm2, orientation='vertical') cb2.set_label('Step') figure.set_size_inches(7.5, 5.15, forward=True) else: figure, (axis0, axis1) = plt.subplots(1, 2, gridspec_kw={ 'width_ratios': [12, 1]}) # type: (object, (matplotlib.axes.Axes, matplotlib.axes.Axes)) if path3 is not None: # get x's and y's x3 = [s[0] for s in path3] y3 = [s[1] for s in path3] # color map variables to configure a gradient along the trajectory color_num_scale3 = np.linspace(0, len(path3), len(path3)) cmap3 = truncate_colormap(plt.get_cmap('copper_r'), minval=.05, maxval=.5) norm3 = plt.Normalize(0, len(path3)) # draw trajectory line_collection3 = make_line_collection(x3, y3, color_num_scale3, cmap=cmap3, norm=norm3, linewidth=linewidth) # maybe draw waypoints along trajectory if waypoint_centers is not None: waypoint_cmap = plt.get_cmap('binary') waypoint_color_num_scale = np.linspace(.2, .6, len(waypoint_centers)) waypoint_norm = plt.Normalize(0, 1.0) waypoint_collection = make_ellipse_collection(waypoint_centers, waypoint_color_num_scale, x_radius=radii[0], y_radius=radii[1], cmap=waypoint_cmap, norm=waypoint_norm) axis0.add_collection(waypoint_collection) highlight = None if highlight_waypoint_index is not None: highlight_point = waypoint_centers[highlight_waypoint_index] highlight = Ellipse((highlight_point[0], highlight_point[1]), radii[0] * 2, radii[1] * 2, 0, color="#ff8080") axis0.add_patch(highlight) axis0.set_title(title) # labels/titles axis0.set_xlabel(x_label) axis0.set_ylabel(y_label) if path2: axis0.add_collection(line_collection2) if path3 is not None: axis0.add_collection(line_collection3) axis0.add_collection(line_collection) # add main path axis0.set_xlim(min(x) - radii[0], max(x) + radii[0]) # set graph view cropping thingy axis0.set_ylim(min(y) - radii[1], max(y) + radii[1]) cb1 = matplotlib.colorbar.ColorbarBase(axis1, cmap=cmap, # color bar norm=norm, orientation='vertical') cb1.set_label('Step') plt.tight_layout() return axis0, line_collection, line_collection2, line_collection3, highlight
def drawSVMParaFirgure(xList, yList): ''' #here's our data to plot, all normal Python lists x = [1, 2, 3, 4, 5] y = [0.1, 0.2, 0.3, 0.4, 0.5] intensity = [5, 10, 15, 20, 25,30, 35, 40, 45, 50,55, 60, 65, 70, 75,80, 85, 90, 95, 100,105, .01, 115, 120, 125] #setup the 2D grid with Numpy x, y = np.meshgrid(x, y) #convert intensity (list of lists) to a numpy array for plotting intensity = np.array(intensity).reshape((5, 5)) print(intensity) #now just plug the data into pcolormesh, it's that easy! plt.pcolormesh(x, y, intensity) plt.colorbar() #need a colorbar to show the intensity scale plt.show() #boom ''' gamma = 1e-9 * 4.5 gammaList = [gamma * (10**powE) for powE in range(10)] C = 0.00001 CList = [C * (10**powE) for powE in range(10)] print(gammaList) print(CList) resultList = [] scoreList = [] decision_function = 'ovr' for C in CList: for gamma in gammaList: clf_rbf = svm.SVC(decision_function_shape=decision_function, C=C, kernel='rbf', gamma=gamma) #cross validation #print("rbf cross validation") score_rbf = cross_validation.cross_val_score(clf_rbf, xList, yList, cv=3) mean = score_rbf.mean() resultList.append({'C': C, 'gamme': gamma, 'score': mean}) scoreList.append(mean) scoreList = np.array(scoreList) maxScore = 0 maxResult = [] for result in resultList: score = result['score'] if maxScore < score: maxScore = score maxResult = result print(maxScore, maxResult) x = gammaList y = CList x = range(len(gammaList) + 1) y = range(len(CList) + 1) intensity = scoreList.reshape((len(gammaList), len(CList))) #print(x) #print(y) #print(intensity) #f1 = scoreList.reshape((6, 6)) #setup the 2D grid with Numpy x, y = np.meshgrid(x, y) plt.pcolormesh(x, y, intensity) plt.colorbar() #need a colorbar to show the intensity scale #plt.show() #boom fig = matplotlib.pyplot.gcf() fig.set_size_inches(10.5, 8.5) fig.savefig("SVM_C_gamma.png", dpi=100)
axis.set_major_formatter(matplotlib.ticker.FuncFormatter(lambda tick, position: tick / 10.0 ** scale)) axis.labelpad -= matplotlib.rcParams["font.size"] * 0.25 def scaleLabel(label, scale): return "{0} / ($10^{{{1}}}$)".format(label, scale) def nudge(text, x, y): text.set_transform(text.get_transform() + matplotlib.transforms.Affine2D().translate(x, y)) if __name__ == "__main__": # Pre-configure plot plot = Plot() figure = matplotlib.pyplot.figure() if plot.sig: figure.set_size_inches(plot.args.size, plot.args.size) grid = matplotlib.gridspec.GridSpec(4, 1) axes1 = figure.add_subplot(grid[0:-1, :]) axes2 = figure.add_subplot(grid[-1, :]) else: figure.set_size_inches(plot.args.size, SIZE_FACTOR * plot.args.size) axes1 = figure.gca() if plot.args.logx: axes1.semilogx() elif plot.args.logy: axes1.semilogy() elif plot.args.logxy: axes1.loglog() # Iterate runs driven = {}