Esempio n. 1
0
def plot_cam_location(camera_list, n, fig=None, ax=None):
	FigSz = (8, 8)
	L = np.array([list(c.location[n]) for c in camera_list])
	x = L[:, 0]
	y = L[:, 1]
	z = L[:, 2]
	if not fig:
		fig = plt.figure(figsize=FigSz)
	#view1 = np.array([-85., 60.])
	if not ax:
		ax = Axes3D(fig) #, azim=view1[0], elev=view1[1])
	Axes3D.scatter(ax, x, y, zs=z, color='k')
	zer = np.array
	Axes3D.scatter(ax, zer([0]), zer([0]), zs=zer([5]), color='r')
	ax.set_xlabel('X')
	ax.set_ylabel('Y')
	ax.set_zlabel('Z')
	ax.set_ylim3d(-50, 50)
	ax.set_xlim3d(-50, 50)
	ax.set_zlim3d(0, 50)
	#if Flag['ShowPositions']:
	fig.show()
	#else:
	#	fig.savefig(fName)
	return ax, fig
Esempio n. 2
0
    def onpick(event):

        # get event indices and x y z coord for click
        ind = event.ind[0];
        x_e, y_e, z_e = event.artist._offsets3d;
        print x_e[ind], y_e[ind], z_e[ind];
        seg_coord = [x_e[ind], y_e[ind], z_e[ind]];
        seg_elecs.append(seg_coord);

        # refresh plot with red dots picked and blue dots clean
        #fig.clf();
        seg_arr = np.array(seg_elecs);
        x_f = seg_arr[:,0];
        y_f = seg_arr[:,1];
        z_f = seg_arr[:,2];
        plt.cla();
        Axes3D.scatter3D(ax,x_f,y_f,z_f,s=150,c='r', picker=5);

        # get array of only clean elecs to re-plot as blue dots
        clean_list = list(coords);
        clean_list = [list(i) for i in clean_list];
        for coordin in clean_list:
                if list(coordin) in seg_elecs:
                    clean_list.pop(clean_list.index(coordin));
        clean_coordis = np.array(clean_list);
        x_c = clean_coordis[:,0];
        y_c = clean_coordis[:,1];
        z_c = clean_coordis[:,2];
        Axes3D.scatter3D(ax,x_c, y_c, z_c, s=150,c='b', picker=5);
        time.sleep(0.5);
        plt.draw();
def plotFiguresTemp(xSolid, ySolid, zSolid, xFFDDeform, yFFDDeform, zFFDDeform):
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')

    #fig = plt.figure()
    #ax = fig.gca(projection='3d')

    # Axes3D.plot_wireframe(ax, z, x, y)
    ax.set_xlabel('Z axis')
    ax.set_ylabel('X axis')
    ax.set_zlabel('Y axis')

    #ax.plot_trisurf(zSolid, xSolid, ySolid, cmap=cm.jet, linewidth=0.2)
    ax.plot_wireframe(zSolid, xSolid, ySolid, rstride = 1, cstride = 1, color="y")

    #Axes3D.scatter(ax, zSolid, xSolid, ySolid, s=10, c='b')
    Axes3D.scatter(ax, zFFDDeform, xFFDDeform, yFFDDeform, s=30, c='r')

    # Axes3D.set_ylim(ax, [-0.5,4.5])
    # Axes3D.set_xlim(ax, [-0.5,4.5])
    Axes3D.set_zlim(ax, [-0.7, 0.7])




    plt.show(block=True)
def plotData(tuplesArray):
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')
    
    
    x = []
    y = []
    z = []
    
    for point in tuplesArray:
        x.append(point[0])
        y.append(point[1])
        z.append(point[2])
    

    if (FILEInQuestion == "newsbp.fuselageZ.dat"):
        Axes3D.scatter(ax, x,y,z, s=30, c ='b')
        
        Axes3D.set_zlim(ax, [0, 1000])
        Axes3D.set_ylim(ax, [0, 3000])
        Axes3D.set_xlim(ax, [0, 3000])
        
        ax.set_xlabel('Z axis')
        ax.set_ylabel('X axis')
        ax.set_zlabel('Y axis')
    else:
        Axes3D.scatter(ax, z,x,y, s=30, c ='b')
        
        ax.set_xlabel('Z axis')
        ax.set_ylabel('X axis')
        ax.set_zlabel('Y axis')

    plt.show(block=True)
def plotData2files(tuplesArray1, tuplesArray2):
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')
    
    
    x1 = []
    y1 = []
    z1 = []
    
    for point in tuplesArray1:
        x1.append(point[0])
        y1.append(point[1])
        z1.append(point[2])
    
    x2 = []
    y2 = []
    z2 = []
    
    for point in tuplesArray2:
        x2.append(point[0])
        y2.append(point[1])
        z2.append(point[2])
    
    Axes3D.scatter(ax, x1,y1,z1, s=30, c ='b')
    Axes3D.scatter(ax, x2,y2,z2, s=30, c ='r')

    Axes3D.set_xlim(ax, [0, 2000])
    Axes3D.set_ylim(ax, [0, 3000])
    Axes3D.set_zlim(ax, [0, 1000])

    plt.show(block=True)
    def updatePlot(self, X, Y, Z, population=None):
        self.activePlot = (X,Y,Z)
        x, y = np.meshgrid(X,Y)

        if self.surface is not None:
            self.surface.remove()

        if self.scatter is not None:
            self.scatter.remove()

        # surface
        self.surface = Axes3D.plot_surface(
                self.axes,
                x, y, Z,
                rstride=1,
                cstride=1,
                cmap=cm.coolwarm,
                linewidth=0,
                antialiased=False,
                shade=False,
                alpha=0.5
        )

        # population
        if population is not None:
            self.activePopulation = population
            x, y, z = self.preparePopulationData(population)
            self.scatter = Axes3D.scatter(self.axes, x, y, z, c="r", marker="o")
            self.scatter.set_alpha(1.0)

        # Draw all
        self.canvas.draw()
        self.canvas.flush_events()
 def volume_display(self, zstep = 3.00):
     """
     This is a daring attempt for 3-D plots of all the blobs in the brain. 
     Prerequisites: self.blobs_archive are established.
     The magnification of the microscope must be known.
     """
     fig3 = plt.figure(figsize = (10,6))
     ax_3d = fig3.add_subplot(111, projection = '3d')
     
     for n_frame in self.valid_frames:
         # below the coordinates of the cells are computed.
         blobs_list = self.c_list[n_frame] 
         ys = blobs_list[:,0]*magni_lateral
         xs = blobs_list[:,1]*magni_lateral 
         zs = np.ones(len(blobs_list))*n_frame*zstep
         ss = (np.sqrt(2)*blobs_list[:,2]*magni_lateral)**2*np.pi
         Axes3D.scatter(xs,ys, zs, zdir = 'z', s=ss, c='g')        
     
     
     
     ax_3d.set_xlabel('x (micron)', fontsize = 12)
     ax_3d.set_xlabel('y (micron)', fontsize = 12)
     
     return fig3
     
Esempio n. 8
0
def clust(elect_coords, n_clusts, iters, init_clusts):
    
   # Load resultant coordinates from Hough circles transform
   #coords = scipy.io.loadmat(elect_coords);
   #dat = coords.get('elect_coords');
   dat = elect_coords;

   # Configure Kmeans
   cluster = sklearn.cluster.KMeans();
   cluster.n_clusters= n_clusts;
   cluster.init = 'k-means++';
   cluster.max_iter = iters;
   cluster.verbose = 0;
   cluster.n_init = init_clusts;
   cluster.fit(dat);

   # Grab vector for plotting each dimension
   x = list(cluster.cluster_centers_[:,0]);
   y = list(cluster.cluster_centers_[:,1]);
   z = list(cluster.cluster_centers_[:,2]);
   c = list(cluster.labels_);

   scipy.io.savemat('k_labels.mat', {'labels':cluster.labels_})
   scipy.io.savemat('k_coords.mat', {'coords':cluster.cluster_centers_})

   # plot the results of kmeans
   cmap = colors.Colormap('hot');
   norm  = colors.Normalize(vmin=1, vmax=10);
   s = 64;
   fig = plt.figure();
   ax = fig.add_subplot(111,projection='3d');
   Axes3D.scatter3D(ax,x,y,z,s=s);
   plt.show(fig);
   
   return cluster.cluster_centers_,cluster.labels_;
def plotFigures(xSolid,ySolid,zSolid,xFFDDeform,yFFDDeform,zFFDDeform, xsolidInitial,
               ysolidInitial, zsolidInitial, xFFDInitial, yFFDInitial, zFFDInitial):
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')


    # Axes3D.plot_wireframe(ax, z, x, y)
    ax.set_xlabel('Z axis')
    ax.set_ylabel('X axis')
    ax.set_zlabel('Y axis')

    #Axes3D.scatter(ax, zSolid, xSolid, ySolid, s=10, c='b')
    Axes3D.plot_wireframe(ax, zSolid, xSolid, ySolid, rstride = 1, cstride = 1, color="b")
    Axes3D.scatter(ax, zFFDDeform, xFFDDeform, yFFDDeform, s=30, c='r')

    #Axes3D.scatter(ax, zsolidInitial, xsolidInitial, ysolidInitial, s=10, c='y')
    Axes3D.plot_wireframe(ax, zsolidInitial, xsolidInitial, ysolidInitial,rstride = 1, cstride = 1, color="y")
    Axes3D.scatter(ax, zFFDInitial, xFFDInitial, yFFDInitial, s=30, c='g')

    xZCross = []
    yZCross = []
    zZCross = []

    #plot the points for the limits of each cross section
    for zCrossSect in GLOBAL_zCrossSectionObjects:
        zCrossSectionObject = GLOBAL_zCrossSectionObjects[zCrossSect]

        #add to the arrays, for a fixed z, the following combinations
        # (xmax, ymax) (xmax, ymin) (xmin, ymin) (xmin, ymax)

        # (xmax, ymax)
        xZCross.append(zCrossSectionObject.getXMax())
        yZCross.append(zCrossSectionObject.getYMax())
        zZCross.append(zCrossSect)

        #(xmax, ymin)
        xZCross.append(zCrossSectionObject.getXMax())
        yZCross.append(zCrossSectionObject.getYMin())
        zZCross.append(zCrossSect)

        #(xmin, ymin)
        xZCross.append(zCrossSectionObject.getXMin())
        yZCross.append(zCrossSectionObject.getYMin())
        zZCross.append(zCrossSect)

        #(xmin, ymax)
        xZCross.append(zCrossSectionObject.getXMin())
        yZCross.append(zCrossSectionObject.getYMax())
        zZCross.append(zCrossSect)

    #Axes3D.plot_wireframe(ax, zZCross, xZCross, yZCross)



    #Axes3D.set_ylim(ax, [-0.5,4.5])
    #Axes3D.set_xlim(ax, [-0.5,4.5])
    Axes3D.set_zlim(ax, [-0.7, 0.7])

    plt.show(block=True)
Esempio n. 10
0
def elecDetect(CT_dir, T1_dir, img, thresh, frac, num_gridStrips, n_elects):

    # navigate to dir with CT img
    os.chdir(T1_dir)

    # Extract and apply CT brain mask
    mask_CTBrain(CT_dir, T1_dir, frac)
    masked_img = "masked_" + img

    # run CT_electhresh
    print "::: Thresholding CT at %f stdv :::" % (thresh)
    electhresh(masked_img, thresh)

    # run im_filt to gaussian smooth thresholded image
    fname = "thresh_" + masked_img
    print "::: Applying guassian smooth of 2.5mm to thresh-CT :::"
    img_filt(fname)

    # run hough transform to detect electrodes
    new_fname = "smoothed_" + fname
    print "::: Applying 2d Hough Transform to localize electrode clusts :::"
    elect_coords = CT_hough(CT_dir, new_fname)

    # set up x,y,z coords to view hough results
    x = elect_coords[:, 0]
    x = x.tolist()
    y = elect_coords[:, 1]
    y = y.tolist()
    z = elect_coords[:, 2]
    z = z.tolist()

    # plot the hough results
    s = 64
    fig = plt.figure()
    ax = fig.add_subplot(111, projection="3d")
    Axes3D.scatter3D(ax, x, y, z, s=s)
    plt.show(fig)

    # run K means to find grid and strip clusters
    n_clusts = num_gridStrips
    # number of cluster to find = number of electrodes
    iters = 1000
    init_clusts = n_clusts
    print "::: Performing K-means cluster to find %d grid-strip and noise clusters :::" % (n_clusts)
    [clust_coords, clust_labels] = clust(elect_coords, n_clusts, iters, init_clusts)

    # run K means to find electrode center coordinates
    n_clusts = n_elects
    # number of cluster to find = number of electrodes
    iters = 1000
    init_clusts = n_clusts
    print "::: Performing K-means cluster to find %d electrode centers :::" % (n_clusts)
    [center_coords, labels] = clust(elect_coords, n_clusts, iters, init_clusts)

    print "::: Finished :::"

    return elect_coords, clust_coords, clust_labels
Esempio n. 11
0
    def draw(self, axes: Axes3D):
        R = (self.orientation * (self.orientation_origin.get_inverse())).to_rot_matrix()

        xx = R[0, 0] * self.x + R[0, 1] * self.y + R[0, 2] * self.z
        yy = R[1, 0] * self.x + R[1, 1] * self.y + R[1, 2] * self.z
        zz = R[2, 0] * self.x + R[2, 1] * self.y + R[2, 2] * self.z

        axes.plot_surface(xx, yy, zz, rstride=4, cstride=4, color='b')
        return axes,
Esempio n. 12
0
    def water(self, *argv):  # Dimension is unit type as V(olt) W(att), etc
#        http://matplotlib.org/examples/mplot3d/polys3d_demo.html
        Axes3D.plot_surface(self.signalx, self.signaly, self.signalz)  # till better funcion
        plt.xlabel('time [s]')  # Or Sample number
        plt.ylabel('Frequency [Hz]')  # Or Freq Bins number
        plt.zlabel('voltage [mV]')  # auto add unit here
        plt.title(' ')  # set title
        plt.grid(True)
        plt.show()
Esempio n. 13
0
  def __init__(self,*args,**kwargs):
    if (len(args) > 1) | kwargs.has_key('rect'):
      _Axes3D.__init__(self,*args,**kwargs)

    else:
      rect = (0.1,0.1,0.8,0.8)
      _Axes3D.__init__(self,*args,rect=rect,**kwargs)

    self.cross_section_clim_set = False
    self.pbaspect = np.array([1.0,1.0,1.0])
Esempio n. 14
0
 def addmpl(self, fig):
   self.fig = fig
   self.canvas = FigureCanvas(fig)
   self.mplvl.addWidget(self.canvas)
   self.canvas.draw()
   self.toolbar = NavigationToolbar(self.canvas, 
                                    self.mplwindow, coordinates=True)
   self.mplvl.addWidget(self.toolbar)
   ax = fig.get_axes()[0]
   Axes3D.mouse_init(ax)
Esempio n. 15
0
def addcurve( ax, path, endpoints, color ) :
  px = path[ :,0 ]
  py = path[ :,1 ]
  pz = path[ :,2 ]
  n = len(px) - 1
  q = Axes3D.plot(ax, px, py, zs=pz, c=color, linewidth=2 )
  px = endpoints[ :,0 ]
  py = endpoints[ :,1 ]
  pz = endpoints[ :,2 ]
  print px, py, pz
  q = Axes3D.scatter(ax, px,py, zs=pz, c=color, marker='o', s=60)
def main():
    # initialize ros node
    rospy.init_node('compute_calibration')

    # get path to folder containing recorded data
    filesPath = rospy.get_param('~files_path')

    # load trajectories
    kinectTraj = np.loadtxt('%skinect_trajectory' % (filesPath), delimiter=',')
    baxterTraj = np.loadtxt('%sbaxter_trajectory' % (filesPath), delimiter=',')

    # compute absolute orientation
    kinectOut, rot, trans = absOrientation(kinectTraj,baxterTraj)

    # plot both point sets together
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')

    # plot the data
    Axes3D.scatter(ax, kinectOut[:,0], kinectOut[:,1], kinectOut[:,2], s=20, c='r')
    Axes3D.scatter(ax, baxterTraj[:,0],baxterTraj[:,1], baxterTraj[:,2], s=20, c='b')

    # add labels and title
    ax.set_xticks([])
    ax.set_yticks([])
    ax.set_zticks([])
    ax.set_xlabel('X-axis')
    ax.set_ylabel('Y-axis')
    ax.set_zlabel('Z-axis')
    plt.title('Kinect-Baxter Calibration')
    plt.legend(['Kinect','Baxter'])
    plt.show()

    # get rotation matrix as quaternion and euler angles
    euler = tf.transformations.euler_from_matrix(rot)
    quat = tf.transformations.quaternion_from_euler(*euler)

    # save results to yaml file
    f = open('%skinect_calibration.yaml' % (filesPath), 'w')
    lines = ['trans: [', 'rot: [', 'rot_euler: [']

    for elem in trans: lines[0] += str(elem) + ', '
    lines[0] += ']\n'
    for elem in quat: lines[1] += str(elem) + ', '
    lines[1] += ']\n'
    for elem in euler: lines[2] += str(elem) + ', '
    lines[2] += ']\n'

    lines.append('parent: /base\n')
    lines.append('child: /kinect2_link\n')

    f.writelines(lines)
    f.close()
Esempio n. 17
0
 def Spect(self):  #, dimension):  # Dimension is unit type as V(olt) W(att), etc
     Axes3D.plot_surface(self.signalx, self.signaly, self.signalz)
     if self.signalx.shape == self.signaly.shape == self.signalz.shape:
         pass
     elif self.signalx.shape == (len(self.signalx), ) or self.signaly.shape == (len(self.signaly), ):
     # Check for 1D array both
         if self.signalx.shape == (len(self.signalx), ) and self.signaly.shape == (len(self.signaly), ):
             self.signalx, self.signaly = np.meshgrid(self.signalx, self.signaly)
             nx, mx = np.shape(self.signalx)
             nz, mz = np.shape(self.signalz)
             if nx == nz and mx == mz:
                 pass
             elif nx == mz and mx == nz:
                 self.signalz = np.rot90(self.signalz, 1) 
                 # find out if it has to be 1 or 3
         elif self.signalx.shape == (len(self.signalx), ):
             pass
         elif self.signaly.shape == (len(self.signaly), ):
             pass
         if self.signalx.shape == self.signaly.shape != self.signalz.shape:
             nx, mx = np.shape(self.signalx)
             nz, mz = np.shape(self.signalz)
             if nx == nz and mx == mz:
                 pass
             elif nx == mz and mx == nz:
                 self.signalz = np.rot90(self.signalz, 1) 
                 # find out if it has to be 1 or 3
         elif self.signalx.shape == self.signalz.shape != self.signaly.shape:
             nx, mx = np.shape(self.signalx)
             ny, my = np.shape(self.signalz)
             if nx == ny and mx == my:
                 pass
             elif nx == my and mx == ny:
                 self.signaly = np.rot90(self.signaly, 1) 
                 # find out if it has to be 1 or 3
     elif self.signaly.shape == self.signalz.shape != self.signalx.shape:
         ny, my = np.shape(self.signaly)
         nx, mx = np.shape(self.signalx)
         if ny == nx and my == mx:
             pass
         elif ny == mx and my == nx:
             self.signalz = np.rot90(self.signalz, 1) 
             # find out if it has to be 1 or 3
     else:
         raise MeasError.DataError("No Valid data found in at least one of the axis")
     
     plt.xlabel('time [s]')  # Or Sample number
     plt.ylabel('Frequency [Hz]')  # Or Freq Bins number
     plt.zlabel('voltage [mV]')  # auto add unit here
     plt.title(' ')  # set title
     plt.grid(True)
     plt.show()
Esempio n. 18
0
def plotPCA(proj3D, X_r, PCs, ligs, colors, csvPath, save_flag):
    """
    Plot the PCA data on 2D plot
    """

    # Main figure
    fig = plt.figure(figsize=(13, 12), dpi=100)

    if proj3D:
        ax = fig.add_subplot(111, projection="3d")
        for label, col, x, y, z in zip(ligs, colors,
                                       X_r[:, 0], X_r[:, 1], X_r[:, 2]):
            newCol = makeColor(col)
            Axes3D.scatter(ax, x, y, z, label=label, color=newCol,
                           marker="o", lw=1, s=800)
        ax.set_xlabel("PC1 (" + '{0:g}'.format(PCs[0]) + " %)", fontsize=30)
        ax.set_ylabel("PC2 (" + '{0:g}'.format(PCs[1]) + " %)", fontsize=30)
        ax.set_zlabel("PC3 (" + '{0:g}'.format(PCs[2]) + " %)", fontsize=30)
        ax.tick_params(axis="both", which="major", labelsize=20)
        pngPath = csvPath.replace(".csv", "_3D.png")
    else:
        ax = fig.add_subplot(111)
        for label, col, x, y in zip(ligs, colors, X_r[:, 0], X_r[:, 1]):
            newCol = makeColor(col)
            ax.scatter(x, y, label=label, color=newCol, marker="o", lw=1, s=800)
            # ax.annotate(label, xy=(x, y - 0.05), fontsize=10,
            #             ha='center', va='top')
        ax.set_xlabel("PC1 (" + '{0:g}'.format(PCs[0]) + " %)", fontsize=30)
        ax.set_ylabel("PC2 (" + '{0:g}'.format(PCs[1]) + " %)", fontsize=30)
        ax.tick_params(axis="both", which="major", labelsize=30)
        pngPath = csvPath.replace(".csv", "_2D.png")

    # figTitle = "PCA on " + csvPath + " (PC1=" + pcVals[0] + ", PC2=" +
    # pcVals[1] + ")"
    # ax.text(0.5, 1.04, figTitle, horizontalalignment="center", fontsize=30,
    #         transform=ax.transAxes)

    # Legend figure
    fig_legend = plt.figure(figsize=(13, 12), dpi=100)
    plt.figlegend(*ax.get_legend_handles_labels(), scatterpoints=1,
                  loc="center", fancybox=True,
                  shadow=True, prop={"size": 30})

    # Save figures if save flag was used
    if save_flag:
        print("\nSAVING figures\n")
        fig.savefig(pngPath, bbox_inches="tight")
        fig_legend.savefig(pngPath.replace(".png", "_legend.png"))
    # Otherwise show the plots
    else:
        print("\nSHOWING figures\n")
        plt.show()
Esempio n. 19
0
def makeequator( ax ) :
  npts = 256
  x = numpy.zeros( npts )
  y = numpy.zeros( npts )
  z = numpy.zeros( npts )
  n = 0
  for phi in numpy.arange( 0., 2*math.pi, 2*math.pi/npts ) :
    x[n] = math.cos(phi)
    y[n] = math.sin(phi)
    n = n+1
  q = Axes3D.plot(ax, x, y, zs=z, c='gray' )
  q = Axes3D.plot(ax, x, z, zs=y, c='gray' )
  q = Axes3D.plot(ax, z, y, zs=x, c='gray' )
    def __init__(self, parent):
        self.figure = Figure(tight_layout=True)
        self.canvas = FigureCanvas(self.figure)
        self.canvas.setContentsMargins(0,0,0,0)
        self.axes = self.figure.add_subplot(111, projection='3d')
        Axes3D.set_autoscale_on(self.axes, True)
        Axes3D.autoscale_view(self.axes)
        self.canvas.setParent(parent)
        self.activePlot = None
        self.activePopulation = None

        self.surface = None
        self.scatter = None
Esempio n. 21
0
 def custom_plot(self, additional):
     for k in additional:
         if(k == Simulation.DISCRETIZE):
             for i in range(self.examples.noutputs):
                 for j in range(self.nbr_epoch):
                     if(self.plots['discretize_div'][i][j] != 0):
                         self.plots['discretize'][i][j] /= (self.plots['discretize_div'][i][j] * (self.nbDiscre ** self.nbDiscre))
             
             colors = [(0.2, 0.8, 0.88), 'b', 'g', 'r', 'c', 'm', 'y', 'k', (0.8, 0.1, 0.8), (0., 0.2, 0.5)]
     
             fig = plt.figure()
             ax = fig.add_subplot(111, projection='3d')
             for j in range(self.examples.noutputs):
                 ax.scatter([self.plots['discretize'][j][k] for k in self.plots['discretize_valid'][j]], [j] * 
                             len(self.plots['discretize_valid'][j]), self.plots['discretize_valid'][j], color=colors[j], marker='x')
         
             ax.set_xlabel('DISCRETIZED VALUE')
             ax.set_ylabel('SHAPE')
             ax.set_zlabel('EPOCH')
             
             path = "/tmp/pyplot.%s.%s.png" % (sys.argv[0], time.strftime("%m-%d-%H-%M-%S", time.localtime()))
             plt.savefig(path)
             plt.show()
             
             
             plt.title('Discretize hidden layer')
             plt.ylabel('DISCRETIZED VALUE')
             plt.xlabel("EPOCHS")
             for j in range(self.examples.noutputs):
                 plt.plot(self.plots['discretize_valid'][j], [self.plots['discretize'][j][k] 
                                                              for k in self.plots['discretize_valid'][j]], '.', color=colors[j])
             path = "/tmp/pyplot.%s.%s.png" % (sys.argv[0], time.strftime("%m-%d-%H-%M-%S", time.localtime()))
             try:
                 plt.savefig(path)
             except ValueError:
                 print('Cannot save discretize_cloud')
             try:
                 plt.show()
             except ValueError:
                 print('Cannot display discretize_cloud')
         elif(k == Simulation.PROTOTYPE):
             lplot = [[0. for _ in range(self.examples.ninputs)] for _ in range(self.examples.noutputs)]
             for network in self.networks:
                 for i in range(len(self.examples.inputs)):
                     network['FoN'].calc_output(self.examples.inputs[i])
                     network['SoN'].calc_output(network['FoN'].stateHiddenNeurons)
                     
                     im = index_max(self.examples.outputs[i])
                     
                     for j in range(self.examples.ninputs):
                         lplot[im][j] += network['SoN'].stateOutputNeurons[j]
             
             fig = plt.figure()
             plt.clf()
             for i in range(self.examples.noutputs):
                 rpr.show_repr(lplot[i], self.width, fig, 250 + i, i)
             path = "/tmp/pyplot.%s.%s.png" % (sys.argv[0], time.strftime("%m-%d-%H-%M-%S", time.localtime()))
             plt.savefig(path)
             plt.show()
Esempio n. 22
0
def main():
    global rR
    global v
    #v = polynomial_surface2(rR)
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')
    v=[  345.01147843,  -731.53883648,   701.43498064,  -333.41157482,    61.69405675,   434.95848754,  -734.92037163,   468.45066799,  -108.66899203,   197.05683428,  -229.38490931,    73.72852732,    38.62490216,   -23.11704968,     2.79760705,  1112.02959271, -1850.90352232,  1243.44148281,  -301.1366546,   1096.50133704, -1278.21349214,   419.17838208,   338.80540403,  -201.95899053,    33.68403733,  1333.97626976, -1566.15905716,   552.3302448,    922.09578713,  -558.92492054,   145.7445413,    705.90344671, -442.88105472,   259.89354682,   138.22604583]
    #ax=implicit.plot_implicit(fn4,bbox=(-1.5,0,-3.5,-1.5,-2,1),rc=200,ns=30,colors='b', ax=ax)
    v=[  2.18930311,   0.24260729,  57.46589779,   3.38543536,  -9.56889825,  34.36258001, -36.2221404,    4.86597348,  12.89329227,  21.10709896,  -4.36372996,  -5.89323474,   3.98227029,   0.9848254,    0.23593784, -36.46890674, -25.34400559,  81.86028261,  14.43120124,  44.89510312, -52.04801532,  -9.90597384,  16.49023335,   2.29875215,   0.40597427, -55.46318028, -39.9563639,   26.95078929,  35.15384941, -18.2399162,   5.13417155, -31.78519693, -14.89522473,  10.38829065,  -6.66988281]
    #ax=implicit.plot_implicit(fn4,bbox=(-1.5,0,-3.5,-1.5,-2,1),rc=200,ns=30,colors='r', ax=ax)
    #rR = tree_time.tree_time(rR,0.05)
    rR=array(rR)
    Axes3D.scatter(ax,rR[:,0],rR[:,1],rR[:,2])
    Axes3D.scatter(ax,-0.87676517,-2.5211104,-0.76908632,color='green') 
    plt.show()
Esempio n. 23
0
def visualize( Z, solution=[]):
    Y = np.arange(0,YSIZE,1)
    X = np.arange(0,XSIZE,1)
    fig = plt.figure()
    ax = fig.gca(projection='3d')
    X, Y = np.meshgrid(X, Y)
    surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.coolwarm, linewidth=0, antialiased=False)
    if 0 < len( solution) :
        # TODO plot line not implemented - which function again?
        Axes3D.plot(X, Y, solution)    
    ax.set_zlim(0.0, 1.01)
    ax.zaxis.set_major_locator(LinearLocator(10))
    ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
    fig.colorbar(surf, shrink=0.5, aspect=5)
    plt.show()
Esempio n. 24
0
    def plot_3d(self, z_data, x_coverage, y_coverage, title=None, x_axis_label="X", y_axis_label="Y", z_axis_label="Z"):
        # 3D plotting is sort of a pain in the neck, and heavily dependent on data formatting.  This routine assumes that you are
        # providing the z height data as a two dimensional array array, and that the overall X and Y spans are
        # given, so the routine can automatically compute arrays comprising the X and Y positions.  If your data files contain the X and Y
        # positions explicitly, this routine AND the data file reader will require heavy modification to ensure that the data gets
        # passed and plotted correctly.

        # takes Z data as an X by Y array of z values, and computes the X and Y arrays based on the "coverage" provided and the size
        # of the Z array

        # \todo design a better way of handling x and y coordinates
        # these might be passed as strings by the config parser, so ensure that they are recast as integers
        # \todo use configobj validators to handle this casting
        x_coverage = int(x_coverage)
        y_coverage = int(y_coverage)

        z_data = npy.array(z_data)

        self.clear_figure()
        # set up some borders
        # these borders never go away, and screw up the other plots - leave them out until a better way is found to elegently fix them
        # self.fig.subplots_adjust(left=0.05)
        # self.fig.subplots_adjust(right=0.95)
        # self.fig.subplots_adjust(top=0.97)
        # self.fig.subplots_adjust(bottom = 0.03)

        axes = self.fig.add_subplot(111, projection="3d")

        # allow us to use the mouse to spin the 3d plot around
        Axes3D.mouse_init(axes)

        (x_data, y_data) = compute_3d_coordinates(z_data, x_coverage, y_coverage)

        axes.plot_wireframe(x_data, y_data, z_data)

        if title:
            axes.set_title(title)
        axes.set_xlabel(x_axis_label)
        axes.set_ylabel(y_axis_label)
        axes.set_zlabel(z_axis_label)

        axes.view_init(self.elev_3d, self.azim_3d)
        self.canvas.draw()

        self.current_plot_type = "3D"
Esempio n. 25
0
def drawcylinder( ax ) :
  npts = 2048 
  xa = numpy.array( [-1, 1] )
  ya = numpy.array( [0.,0.] )
  za = numpy.array( [40.,40.] )
  q = Axes3D.plot(ax, xa, za, zs=ya, c='gray' )
  q = Axes3D.plot(ax, ya, za, zs=xa, c='gray' )
  za = numpy.array( [-40.,-40.] )
  q = Axes3D.plot(ax, xa, za, zs=ya, c='gray' )
  q = Axes3D.plot(ax, ya, za, zs=xa, c='gray' )
  xa = numpy.array( [0.,0.] )
  za = numpy.array( [0.,0.] )
  ya = numpy.array( [-40.,40.] )
  q = Axes3D.plot(ax, xa, ya, zs=za, c='gray', linestyle='--' )

  x = numpy.zeros( npts )
  y = -30.*numpy.ones( npts )
  z = numpy.zeros( npts )
  xx = numpy.zeros( npts )
  yy = numpy.zeros( npts )
  zz = numpy.zeros( npts )

  n = 0
  for phi in numpy.arange( 0., 2*math.pi, 2*math.pi/npts ) :
    x[n] = math.cos(phi)
    z[n] = math.sin(phi)
    n = n+1
  #q = Axes3D.plot(ax, x, y, zs=z, c='gray' )
  y = 30.* numpy.ones( npts )
  #q = Axes3D.plot(ax, x, y, zs=z, c='gray' )
  n = 0
  for phi in numpy.arange( -30., 30.0, (60./npts) ) :
    yy[n] = phi
    amp = math.cos(phi)
    zz[n] = amp * math.cos( .007 * (30.-phi) )
    xx[n] = -1.* amp * math.sin( .007 * (30.-phi) )
    #zz[n] = math.cos(phi)
    n = n+1
  q = Axes3D.plot(ax, xx, yy, zs=zz, c='black' )
  xxx = numpy.zeros( 2 )
  yyy = 40.*numpy.ones( 2 )
  zzz = numpy.zeros( 2 )
  zzz[0] = -1.
  zzz[1] = 1. 
  q = Axes3D.plot(ax, xxx, yyy, zs=zzz, c='black' )
  xxxx = numpy.zeros( 2 )
  yyyy = -40.*numpy.ones( 2 )
  zzzz = numpy.zeros( 2 )
  xxxx[0] = -1.* math.sin( .007 * (60.) )
  zzzz[0] = math.cos( .007 * (60.) )
  xxxx[1] = 1.* math.sin( .007 * (60.) )
  zzzz[1] = -1.* math.cos( .007 * (60.) )
  q = Axes3D.plot(ax, xxxx, yyyy, zs=zzzz, c='black' )
Esempio n. 26
0
def vectorplot(Points_From,Points_To):



    import matplotlib.pyplot as plt
    from mpl_toolkits.mplot3d import Axes3D

    from matplotlib.patches import FancyArrowPatch
    from mpl_toolkits.mplot3d import proj3d
    
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')

    

    for i in range(len(Points_From)):
#        ax.plot([Points_From[i][0], Points_To[i][0]], [Points_From[i][1], Points_To[i][1]],zs=[Points_From[i][2], Points_To[i][2]])
        a=Arrow3D([Points_From[i][0], Points_To[i][0]], [Points_From[i][1], Points_To[i][1]],[Points_From[i][2], Points_To[i][2]],mutation_scale=2000, lw=3, arrowstyle="-|>", color="r")
        ax.add_artist(a)
    plt.show()
    Axes3D.plot()
    def updatePopulation(self, population):
        self.activePopulation = population
        x, y, z = self.preparePopulationData(population)

        if self.scatter is not None:
            self.scatter.remove()

        self.scatter = Axes3D.scatter(self.axes, x, y, z, c="r", marker="o")
        # self.surface.set_zorder(2)
        # self.scatter.set_zorder(100)
        self.scatter.set_alpha(1.0)
        self.canvas.draw()
        self.canvas.flush_events()
Esempio n. 28
0
def plotElements(PhysicalElementMatrix):
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')
    
    # Axes3D.plot_wireframe(ax, z, x, y)
    ax.set_xlabel('X axis')
    ax.set_ylabel('Y axis')
    ax.set_zlabel('Z axis')
    

    xVector = []
    yVector = []
    zVector = []
    for i in range(CONST_DIMENSION_X):
        for j in range(CONST_DIMENSION_Y):
            for k in range(CONST_DIMENSION_Z):
                elementObject = PhysicalElementMatrix[i][j][k]
                for gridPointObject in elementObject.gridPointList:
                    xVector.append(gridPointObject.getX())
                    yVector.append(gridPointObject.getY())
                    zVector.append(gridPointObject.getZ())

    Axes3D.scatter(ax, xVector, yVector, zVector, s=30, c='r')

    #Axes3D.plot_wireframe(ax, zSolid, xSolid, ySolid, rstride = 1, cstride = 1, color="b")



    # create the lines around all the elements
    for i in range(CONST_DIMENSION_X):
        for j in range(CONST_DIMENSION_Y):
            for k in range(CONST_DIMENSION_Z):
                elementObject = PhysicalElementMatrix[i][j][k]
                ListXVectors,ListYVectors,ListZVectors = elementObject.getOuterLineVectors()
                for l in range(len(ListXVectors)):
                    plt.plot(ListXVectors[l],ListYVectors[l], ListZVectors[l], c = 'b')

    Axes3D.set_ylim(ax, [-10,10])
    Axes3D.set_xlim(ax, [-10,10])
    Axes3D.set_zlim(ax, [-10, 10])
    

    plt.show(block=True)
def plotElements(fig, ax, ElementsSbpData, ElementsFFDData, NumElements,c1,c2,\
                 c3,c4):
    
    for i in range(NumElements):
        xSolid = []
        ySolid = []
        zSolid = []
        
        xFFD = []
        yFFD = []
        zFFD = []
        
        #fill the Solid body points


        for SBPTuple in ElementsSbpData[i]:
            xSolid.append(SBPTuple[0][0])
            ySolid.append(SBPTuple[0][1])
            zSolid.append(SBPTuple[0][2])
        
        
        for FFDTuple in ElementsFFDData[i]:
            xFFD.append(FFDTuple[1][0])
            yFFD.append(FFDTuple[1][1])
            zFFD.append(FFDTuple[1][2])

        # element 1 is the fuselage whose x and z values were switched
        # to make z cross sections. So switch these back when plotting
        
        if(i == 0):
            #ax.plot_trisurf(zSolid, xSolid, ySolid, cmap=cm.jet, linewidth=0.2)
            Axes3D.scatter(ax, zSolid,xSolid, ySolid, s=20, c=c1)
            Axes3D.scatter(ax, zFFD, xFFD, yFFD, s=30, c= c2)
            #Axes3D.plot_wireframe(ax, zFFD, xFFD, yFFD)
        if(i == 1):
            #ax.plot_trisurf(xSolid, zSolid, ySolid, cmap=cm.jet, linewidth=0.2)
            Axes3D.scatter(ax, zSolid,xSolid, ySolid, s=20, c=c3)
            Axes3D.scatter(ax, zFFD, xFFD, yFFD, s=30, c= c4)
Esempio n. 30
0
def plotFiguresTemp(xSolid, ySolid, zSolid, xFFDDeform, yFFDDeform, zFFDDeform):
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')

    # Axes3D.plot_wireframe(ax, z, x, y)
    ax.set_xlabel('Z axis')
    ax.set_ylabel('X axis')
    ax.set_zlabel('Y axis')

    Axes3D.scatter(ax, zSolid, xSolid, ySolid, s=10, c='b')
    Axes3D.scatter(ax, zFFDDeform, xFFDDeform, yFFDDeform, s=30, c='r')

    # Axes3D.set_ylim(ax, [-0.5,4.5])
    # Axes3D.set_xlim(ax, [-0.5,4.5])
    Axes3D.set_zlim(ax, [-0.7, 0.7])

    plt.show(block=True)
Esempio n. 31
0
def train(net, x_train, x_test, y_train, y_test, lr, epoches):
    train_losses = []
    test_losses = []
    plt.ion()
    print_interval = int(epoches*0.2)
    for i in range(epoches):
        print('i=', i)
        # 为了得到更好的效果,适当改变学习率
        if i%print_interval==0 and i!=0:
            lr=lr*0.8
            print('-----------learning rate=',lr,'------------')
        for j in range(len(x_train)):
            net.back_propagation(x_train[j], y_train[j], lr)
            if i%print_interval==0:
                # 均方差
                train_loss = np.mean(np.square(y_train - net.forward_propagation(x_train)))
                test_loss = np.mean(np.square(y_test - net.forward_propagation(x_test)))
                train_losses.append(train_loss)
                test_losses.append(test_loss)
                print('Epoch=', i, ', train_loss=', train_loss, ', test_loss=', test_loss)
                # 回想泛化实况
                plt.figure(1)
                plt.cla()
                xx = np.linspace(1, len(test_losses), len(test_losses))
                plt.title("generalization")
                plt.xlabel('epoches')
                plt.ylabel('test_loss')
                plt.plot(xx, test_losses)
                # plt.show()

                plt.figure(2)
                plt.cla()
                xx = np.linspace(1, len(train_losses), len(train_losses))
                plt.title("recall")
                plt.xlabel('epoches')
                plt.ylabel('train_loss')
                plt.plot(xx, train_losses)

                # 二维空间函数拟合
                if len(x_train[0])==1:
                    plt.figure(3)
                    plt.cla()
                    plt.scatter(x_train, y_train, s=5)
                    plt.scatter(x_train,net.forward_propagation(x_train),s=4 , color='red')
                    plt.text(1.5,0.2,'train loss=%.6lf'%train_loss,fontdict={'size':15,'color':'red','style':'italic'})

                    plt.figure(4)
                    plt.cla()
                    plt.scatter(x_test, y_test, s=5)
                    plt.scatter(x_test, net.forward_propagation(x_test), s=4, color='black')
                    plt.text(plt.axis()[0]+0.1,plt.axis()[2]+0.1,'test loss=%.6lf'%test_loss,fontdict={'size':15,'color':'blue','style':'italic'})

                    plt.pause(0.01)
                # 三维空间函数拟合
                elif len(x_train[0])==2:
                    x1_train = x_train[:, 0]
                    x2_train = x_train[:, 1]
                    x1_train, x2_train = np.meshgrid(x1_train, x2_train)
                    trainY = np.add(x1_train, x2_train)
                    x1_test = x_test[:, 0]
                    x2_test = x_test[:, 1]
                    x1_test, x2_test = np.meshgrid(x1_test, x2_test)
                    testY = np.add(x1_test, x2_test)
                    a = []
                    b = []
                    
                    for k in x1_train:
                        for p in x2_train:
                            m = np.vstack((k, p)).T
                            a.append(m)
                    a = np.array(a)
                    a.resize((x1_train.shape[0]*x2_train.shape[0], 2))

                    for k in x1_test:
                        for p in x2_test:
                            m = np.vstack((k, p)).T
                            b.append(m)
                    b = np.array(b)
                    b.resize((x1_test.shape[0]*x2_test.shape[0], 2))
                    trainy =  net.forward_propagation(a).reshape((x1_train.shape[0], x2_train.shape[0]))
                    testy = net.forward_propagation(b).reshape((x1_test.shape[0], x2_test.shape[0]))
                    # print(trainy.shape, testy.shape) #(280, 280), (120, 120)

                    fig1 = plt.figure(3, figsize=(6, 4))
                    plt.cla()
                    ax1=Axes3D(fig1)
                    ax1.scatter(x1_train, x2_train, trainY, ) # 预期输出
                    ax1.scatter(x1_train, x2_train, trainy, ) # 实际输出
                    ax1.text(plt.axis()[1]-0.1, plt.axis()[2]+0.1, 0, 'train loss=%.6lf'%train_loss, fontdict={'size':15,'color':'blue','style':'italic'})
                    ax1.set_xlabel('x1')
                    ax1.set_ylabel('x2')
                    ax1.set_zlabel('y')

                    fig2 = plt.figure(4, figsize=(6, 4))
                    plt.cla()
                    ax2=Axes3D(fig2)
                    ax2.scatter(x1_test, x2_test, testY, )
                    ax2.scatter(x1_test, x2_test, testy, )
                    ax2.text(plt.axis()[1]-0.1, plt.axis()[2]+0.1, 0, 'test loss=%.6lf'%test_loss, fontdict={'size':15,'color':'blue','style':'italic'})
                    ax2.set_xlabel('x1')
                    ax2.set_ylabel('x2')
                    ax2.set_zlabel('y')
                    plt.pause(0.01)

    plt.show()
    plt.ioff()
    return train_losses, test_losses
Esempio n. 32
0
def plot_surf(surf_mesh,
              surf_map=None,
              bg_map=None,
              hemi='left',
              view='lateral',
              cmap=None,
              colorbar=False,
              avg_method='mean',
              threshold=None,
              alpha='auto',
              bg_on_data=False,
              darkness=1,
              vmin=None,
              vmax=None,
              cbar_vmin=None,
              cbar_vmax=None,
              title=None,
              output_file=None,
              axes=None,
              figure=None,
              **kwargs):
    """ Plotting of surfaces with optional background and data

    .. versionadded:: 0.3

    Parameters
    ----------
    surf_mesh: str or list of two numpy.ndarray
        Surface mesh geometry, can be a file (valid formats are
        .gii or Freesurfer specific files such as .orig, .pial,
        .sphere, .white, .inflated) or
        a list of two Numpy arrays, the first containing the x-y-z coordinates
        of the mesh vertices, the second containing the indices
        (into coords) of the mesh faces.

    surf_map: str or numpy.ndarray, optional.
        Data to be displayed on the surface mesh. Can be a file (valid formats
        are .gii, .mgz, .nii, .nii.gz, or Freesurfer specific files such as
        .thickness, .curv, .sulc, .annot, .label) or
        a Numpy array with a value for each vertex of the surf_mesh.

    bg_map: Surface data object (to be defined), optional,
        Background image to be plotted on the mesh underneath the
        surf_data in greyscale, most likely a sulcal depth map for
        realistic shading.

    hemi : {'left', 'right'}, default is 'left'
        Hemisphere to display.

    view: {'lateral', 'medial', 'dorsal', 'ventral', 'anterior', 'posterior'},
        default is 'lateral'
        View of the surface that is rendered.

    cmap: matplotlib colormap, str or colormap object, default is None
        To use for plotting of the stat_map. Either a string
        which is a name of a matplotlib colormap, or a matplotlib
        colormap object. If None, matplotlib default will be chosen

    colorbar : bool, optional, default is False
        If True, a colorbar of surf_map is displayed.

    avg_method: {'mean', 'median'}, default is 'mean'
        How to average vertex values to derive the face value, mean results
        in smooth, median in sharp boundaries.

    threshold : a number or None, default is None.
        If None is given, the image is not thresholded.
        If a number is given, it is used to threshold the image, values
        below the threshold (in absolute value) are plotted as transparent.

    alpha: float, alpha level of the mesh (not surf_data), default 'auto'
        If 'auto' is chosen, alpha will default to .5 when no bg_map
        is passed and to 1 if a bg_map is passed.

    bg_on_data: bool, default is False
        If True, and a bg_map is specified, the surf_data data is multiplied
        by the background image, so that e.g. sulcal depth is visible beneath
        the surf_data.
        NOTE: that this non-uniformly changes the surf_data values according
        to e.g the sulcal depth.

    darkness: float, between 0 and 1, default is 1
        Specifying the darkness of the background image.
        1 indicates that the original values of the background are used.
        .5 indicates the background values are reduced by half before being
        applied.

    vmin, vmax: lower / upper bound to plot surf_data values
        If None , the values will be set to min/max of the data

    title : str, optional
        Figure title.

    output_file: str, or None, optional
        The name of an image file to export plot to. Valid extensions
        are .png, .pdf, .svg. If output_file is not None, the plot
        is saved to a file, and the display is closed.

    axes: instance of matplotlib axes, None, optional
        The axes instance to plot to. The projection must be '3d' (e.g.,
        `figure, axes = plt.subplots(subplot_kw={'projection': '3d'})`,
        where axes should be passed.).
        If None, a new axes is created.

    figure: instance of matplotlib figure, None, optional
        The figure instance to plot to. If None, a new figure is created.

    See Also
    --------
    nilearn.datasets.fetch_surf_fsaverage : For surface data object to be
        used as background map for this plotting function.

    nilearn.plotting.plot_surf_roi : For plotting statistical maps on brain
        surfaces.

    nilearn.plotting.plot_surf_stat_map : for plotting statistical maps on
        brain surfaces.
    """

    # load mesh and derive axes limits
    mesh = load_surf_mesh(surf_mesh)
    coords, faces = mesh[0], mesh[1]
    limits = [coords.min(), coords.max()]

    # set view
    if hemi == 'right':
        if view == 'lateral':
            elev, azim = 0, 0
        elif view == 'medial':
            elev, azim = 0, 180
        elif view == 'dorsal':
            elev, azim = 90, 0
        elif view == 'ventral':
            elev, azim = 270, 0
        elif view == 'anterior':
            elev, azim = 0, 90
        elif view == 'posterior':
            elev, azim = 0, 270
        else:
            raise ValueError('view must be one of lateral, medial, '
                             'dorsal, ventral, anterior, or posterior')
    elif hemi == 'left':
        if view == 'medial':
            elev, azim = 0, 0
        elif view == 'lateral':
            elev, azim = 0, 180
        elif view == 'dorsal':
            elev, azim = 90, 0
        elif view == 'ventral':
            elev, azim = 270, 0
        elif view == 'anterior':
            elev, azim = 0, 90
        elif view == 'posterior':
            elev, azim = 0, 270
        else:
            raise ValueError('view must be one of lateral, medial, '
                             'dorsal, ventral, anterior, or posterior')
    else:
        raise ValueError('hemi must be one of right or left')

    # set alpha if in auto mode
    if alpha == 'auto':
        if bg_map is None:
            alpha = .5
        else:
            alpha = 1

    # if no cmap is given, set to matplotlib default
    if cmap is None:
        cmap = plt.cm.get_cmap(plt.rcParamsDefault['image.cmap'])
    else:
        # if cmap is given as string, translate to matplotlib cmap
        if isinstance(cmap, str):
            cmap = plt.cm.get_cmap(cmap)

    # initiate figure and 3d axes
    if axes is None:
        if figure is None:
            figure = plt.figure()
        axes = Axes3D(figure, rect=[0, 0, 1, 1], xlim=limits, ylim=limits)
    else:
        if figure is None:
            figure = axes.get_figure()
        axes.set_xlim(*limits)
        axes.set_ylim(*limits)
    axes.view_init(elev=elev, azim=azim)
    axes.set_axis_off()

    # plot mesh without data
    p3dcollec = axes.plot_trisurf(coords[:, 0],
                                  coords[:, 1],
                                  coords[:, 2],
                                  triangles=faces,
                                  linewidth=0.,
                                  antialiased=False,
                                  color='white')

    # reduce viewing distance to remove space around mesh
    axes.dist = 8

    # set_facecolors function of Poly3DCollection is used as passing the
    # facecolors argument to plot_trisurf does not seem to work
    face_colors = np.ones((faces.shape[0], 4))

    if bg_map is None:
        bg_data = np.ones(coords.shape[0]) * 0.5

    else:
        bg_data = load_surf_data(bg_map)
        if bg_data.shape[0] != coords.shape[0]:
            raise ValueError('The bg_map does not have the same number '
                             'of vertices as the mesh.')

    bg_faces = np.mean(bg_data[faces], axis=1)
    if bg_faces.min() != bg_faces.max():
        bg_faces = bg_faces - bg_faces.min()
        bg_faces = bg_faces / bg_faces.max()
    # control background darkness
    bg_faces *= darkness
    face_colors = plt.cm.gray_r(bg_faces)

    # modify alpha values of background
    face_colors[:, 3] = alpha * face_colors[:, 3]
    # should it be possible to modify alpha of surf data as well?

    if surf_map is not None:
        surf_map_data = load_surf_data(surf_map)
        if surf_map_data.ndim != 1:
            raise ValueError('surf_map can only have one dimension but has'
                             '%i dimensions' % surf_map_data.ndim)
        if surf_map_data.shape[0] != coords.shape[0]:
            raise ValueError('The surf_map does not have the same number '
                             'of vertices as the mesh.')

        # create face values from vertex values by selected avg methods
        if avg_method == 'mean':
            surf_map_faces = np.mean(surf_map_data[faces], axis=1)
        elif avg_method == 'median':
            surf_map_faces = np.median(surf_map_data[faces], axis=1)

        # if no vmin/vmax are passed figure them out from data
        if vmin is None:
            vmin = np.nanmin(surf_map_faces)
        if vmax is None:
            vmax = np.nanmax(surf_map_faces)

        # treshold if inidcated
        if threshold is None:
            kept_indices = np.arange(surf_map_faces.shape[0])
        else:
            kept_indices = np.where(np.abs(surf_map_faces) >= threshold)[0]

        surf_map_faces = surf_map_faces - vmin
        surf_map_faces = surf_map_faces / (vmax - vmin)

        # multiply data with background if indicated
        if bg_on_data:
            face_colors[kept_indices] = cmap(surf_map_faces[kept_indices])\
                * face_colors[kept_indices]
        else:
            face_colors[kept_indices] = cmap(surf_map_faces[kept_indices])

        if colorbar:
            our_cmap = get_cmap(cmap)
            norm = Normalize(vmin=vmin, vmax=vmax)

            nb_ticks = 5
            ticks = np.linspace(vmin, vmax, nb_ticks)
            bounds = np.linspace(vmin, vmax, our_cmap.N)

            if threshold is not None:
                cmaplist = [our_cmap(i) for i in range(our_cmap.N)]
                # set colors to grey for absolute values < threshold
                istart = int(norm(-threshold, clip=True) * (our_cmap.N - 1))
                istop = int(norm(threshold, clip=True) * (our_cmap.N - 1))
                for i in range(istart, istop):
                    cmaplist[i] = (0.5, 0.5, 0.5, 1.)
                our_cmap = LinearSegmentedColormap.from_list(
                    'Custom cmap', cmaplist, our_cmap.N)

            # we need to create a proxy mappable
            proxy_mappable = ScalarMappable(cmap=our_cmap, norm=norm)
            proxy_mappable.set_array(surf_map_faces)
            cax, kw = make_axes(axes,
                                location='right',
                                fraction=.1,
                                shrink=.6,
                                pad=.0)
            cbar = figure.colorbar(proxy_mappable,
                                   cax=cax,
                                   ticks=ticks,
                                   boundaries=bounds,
                                   spacing='proportional',
                                   format='%.2g',
                                   orientation='vertical')
            _crop_colorbar(cbar, cbar_vmin, cbar_vmax)

        p3dcollec.set_facecolors(face_colors)

    if title is not None:
        axes.set_title(title, position=(.5, .95))

    # save figure if output file is given
    if output_file is not None:
        figure.savefig(output_file)
        plt.close(figure)
    else:
        return figure
Esempio n. 33
0
def hist3d(y_label, x_label, z_value, \
           y_label_name = "y", x_label_name = "x", z_label_name = "z", output_filepath = "..\\result\\lsfs_featue_namuda.png"):

    """
    y -> row -> data.shape[0]
    x -> column -> data->shape[1]
    """
    
    column_names = x_label.copy()
    row_names = y_label.copy()



    data = z_value.copy()

    fig = plt.figure(figsize=(8, 5))
    ax = Axes3D(fig)

    lx= len(data[0])            # Work out matrix dimensions
    ly= len(data[:,0])
    xpos = np.arange(0,lx,1)    # Set up a mesh of positions
    ypos = np.arange(0,ly,1)
    xpos, ypos = np.meshgrid(xpos+0.25, ypos+0.25)

    xpos = xpos.flatten()   # Convert positions to 1D array
    ypos = ypos.flatten()
    zpos = np.zeros(lx*ly)

    dx = 0.5 * np.ones_like(zpos)
    dy = dx.copy()
    dz = data.flatten()
    
    bar_colors = ['red', 'green', 'blue', 'aqua',
          'burlywood', 'cadetblue', 'chocolate', 'cornflowerblue',
          'crimson', 'darkcyan', 'darkgoldenrod', 'darkgreen',
          'purple', 'darkred', 'darkslateblue', 'darkviolet']
    
    colors = []
    
    for i in range(len(y_label)):
        for j in range(len(x_label)):
            colors.append(bar_colors[i])
            
    ax.bar3d(xpos,ypos,zpos, dx, dy, dz, color=colors, alpha = 0.6)

    #sh()
    ax.w_xaxis.set_ticklabels(x_label)
    ax.w_yaxis.set_ticklabels(y_label)
    ax.set_xlabel(x_label_name)
    ax.set_ylabel(y_label_name)
    ax.set_zlabel(z_label_name)

    #ax.w_xaxis.set_ticklabels(column_names)
    #ax.w_yaxis.set_ticklabels(row_names)

    # start, stop, step
    ticksx = np.arange(0.5, lx, 1)
    plt.xticks(ticksx, x_label)

    ticksy = np.arange(0.6, ly, 1)
    plt.yticks(ticksy, y_label)
    
    plt.savefig(output_filepath)
    print("save to ", output_filepath)
    plt.close()
import os
import pylab as pl
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
from matplotlib import cm
from matplotlib.ticker import LinearLocator, FormatStrFormatter
import numpy as np

os.system("clear")


fig = pl.figure()
axx = Axes3D(fig)
raiz=np.sqrt
ln=np.log
 
X = np.arange(-2, 12, 0.1)
Y = np.arange(-2, 12, 0.1)

X[25]=0.49
X[65]=4.49
X[105]=8.49
Y[25]=0.49
Y[65]=4.49
Y[105]=8.49

X, Y = np.meshgrid(X, Y)


ax, ay = 0, 0
bx, by = 4, 0
Esempio n. 35
0
vind = [[node1[i], node2[i], node3[i]]
        for i in range(ntria)]
# vind = np.matrix([[node1[i], node2[i], node3[i]]
#    for i in range(ntria)])
print(vind)
x = xpts
y = ypts
z = zpts
r = [[x[i], y[i], z[i]]
     for i in range(nverts)]
# r = np.matrix([[x[i], y[i], z[i]]
#    for i in range(nverts)])
print(r)
# inicio plot
fig1 = plt.figure()
ax = Axes3D(fig1)
# print(x[int(vind[0][0])])
# print(vind[0][0])
# int(vind[0][0])
# print(isinstance(int(vind[0][0]), float))
print(x)
for i in range(ntria):
    # print(int(vind[i][0]))
    # Xa = [x[int(vind[0][0])]]# , x[int(vind[i][1])], x[int(vind[i][2])], x[int(vind[i][0])]]
    Xa = [int(r[int(vind[i][0])-1][0]), int(r[int(vind[i][1])-1][0]), int(r[int(vind[i][2])-1][0]), int(r[int(vind[i][0])-1][0])]
    print(Xa)
    Ya = [int(r[int(vind[i][0])-1][1]), int(r[int(vind[i][1])-1][1]), int(r[int(vind[i][2])-1][1]), int(r[int(vind[i][0])-1][1])]
    # print(Ya)
    Za = [int(r[int(vind[i][0])-1][2]), int(r[int(vind[i][1])-1][2]), int(r[int(vind[i][2])-1][2]), int(r[int(vind[i][0])-1][2])]
    # print(Za)
    # ax.plot3D(Xa, Ya, Za)
Esempio n. 36
0
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

X = [1, 1, 2, 2]
Y = [3, 4, 4, 3]
Z = [1, 100, 1, 1]

figure = plt.figure()

ax = Axes3D(figure)
ax.plot_trisurf(X, Y, Z)

plt.show()
Esempio n. 37
0
import math


def fonction(X, Y):
    return X * np.exp(-X**2 - Y**2) + (X**2 + Y**2) / 20


def gradient_fonction(X, Y):
    g_x = np.exp(-X**2 - Y**2) + X * -2 * X * np.exp(-X**2 - Y**2) + X / 10
    g_y = -2 * Y * X * np.exp(-X**2 - Y**2) + Y / 10
    return g_x, g_y


fig = plt.figure()
fig.set_size_inches(9, 7, forward=True)
ax = Axes3D(fig, azim=-29, elev=49)
X = np.arange(-3, 3, 0.2)
Y = np.arange(-3, 3, 0.2)
X, Y = np.meshgrid(X, Y)
Z = fonction(X, Y)
ax.plot_wireframe(X, Y, Z, rstride=1, cstride=1)
#ax.contour(X, Y, Z, 70, rstride=1, cstride=1, cmap='plasma')

plt.xlabel("Paramètre 1 (x)")
plt.ylabel("Paramètre 2 (y)")

x = np.random.random_integers(-2, 2) + np.random.rand(1)[0]
y = np.random.random_integers(-2, 2) + np.random.rand(1)[0]

lr = 0.2
lr2 = 0.9
Esempio n. 38
0
def sphereplot(theta, phi, values, fig=None, ax=None, save=False):
    """Plots a matrix of values on a sphere

    Parameters
    ----------
    theta : float
        Angle with respect to z-axis

    phi : float
        Angle in x-y plane

    values : array
        Data set to be plotted

    fig : a matplotlib Figure instance
        The Figure canvas in which the plot will be drawn.

    ax : a matplotlib axes instance
        The axes context in which the plot will be drawn.

    save : bool {False , True}
        Whether to save the figure or not

    Returns
    -------
    fig, ax : tuple
        A tuple of the matplotlib figure and axes instances used to produce
        the figure.
    """
    if fig is None or ax is None:
        fig = plt.figure()
        ax = Axes3D(fig)

    thetam, phim = np.meshgrid(theta, phi)
    xx = sin(thetam) * cos(phim)
    yy = sin(thetam) * sin(phim)
    zz = cos(thetam)
    r = array(abs(values))
    ph = angle(values)
    # normalize color range based on phase angles in list ph
    nrm = mpl.colors.Normalize(ph.min(), ph.max())

    # plot with facecolors set to cm.jet colormap normalized to nrm
    surf = ax.plot_surface(r * xx,
                           r * yy,
                           r * zz,
                           rstride=1,
                           cstride=1,
                           facecolors=cm.jet(nrm(ph)),
                           linewidth=0)
    # create new axes on plot for colorbar and shrink it a bit.
    # pad shifts location of bar with repsect to the main plot
    cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)

    # create new colorbar in axes cax with cm jet and normalized to nrm like
    # our facecolors
    cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cm.jet, norm=nrm)
    # add our colorbar label
    cb1.set_label('Angle')

    if save:
        plt.savefig("sphereplot.png")

    return fig, ax
Esempio n. 39
0
def plot_spin_distribution_3d(P,
                              THETA,
                              PHI,
                              fig=None,
                              ax=None,
                              figsize=(8, 6)):
    """Plots a matrix of values on a sphere

    Parameters
    ----------
    P : matrix
        Distribution values as a meshgrid matrix.

    THETA : matrix
        Meshgrid matrix for the theta coordinate.

    PHI : matrix
        Meshgrid matrix for the phi coordinate.

    fig : a matplotlib figure instance
        The figure canvas on which the plot will be drawn.

    ax : a matplotlib axis instance
        The axis context in which the plot will be drawn.

    figsize : (width, height)
        The size of the matplotlib figure (in inches) if it is to be created
        (that is, if no 'fig' and 'ax' arguments are passed).

    Returns
    -------
    fig, ax : tuple
        A tuple of the matplotlib figure and axes instances used to produce
        the figure.

    """

    if fig is None or ax is None:
        fig = plt.figure(figsize=figsize)
        ax = Axes3D(fig, azim=-35, elev=35)

    xx = sin(THETA) * cos(PHI)
    yy = sin(THETA) * sin(PHI)
    zz = cos(THETA)

    if P.min() < -1e12:
        cmap = cm.RdBu
        norm = mpl.colors.Normalize(-P.max(), P.max())
    else:
        cmap = cm.RdYlBu
        norm = mpl.colors.Normalize(P.min(), P.max())

    surf = ax.plot_surface(xx,
                           yy,
                           zz,
                           rstride=1,
                           cstride=1,
                           facecolors=cmap(norm(P)),
                           linewidth=0)

    cax, kw = mpl.colorbar.make_axes(ax, shrink=.66, pad=.02)
    cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
    cb1.set_label('magnitude')

    return fig, ax
Esempio n. 40
0
def matrix_histogram(M,
                     xlabels=None,
                     ylabels=None,
                     title=None,
                     limits=None,
                     colorbar=True,
                     fig=None,
                     ax=None):
    """
    Draw a histogram for the matrix M, with the given x and y labels and title.

    Parameters
    ----------
    M : Matrix of Qobj
        The matrix to visualize

    xlabels : list of strings
        list of x labels

    ylabels : list of strings
        list of y labels

    title : string
        title of the plot (optional)

    limits : list/array with two float numbers
        The z-axis limits [min, max] (optional)

    ax : a matplotlib axes instance
        The axes context in which the plot will be drawn.

    Returns
    -------
    fig, ax : tuple
        A tuple of the matplotlib figure and axes instances used to produce
        the figure.

    Raises
    ------
    ValueError
        Input argument is not valid.

    """

    if isinstance(M, Qobj):
        # extract matrix data from Qobj
        M = M.full()

    n = np.size(M)
    xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
    xpos = xpos.T.flatten() - 0.5
    ypos = ypos.T.flatten() - 0.5
    zpos = np.zeros(n)
    dx = dy = 0.8 * np.ones(n)
    dz = np.real(M.flatten())

    if limits and type(limits) is list and len(limits) == 2:
        z_min = limits[0]
        z_max = limits[1]
    else:
        z_min = min(dz)
        z_max = max(dz)
        if z_min == z_max:
            z_min -= 0.1
            z_max += 0.1

    norm = mpl.colors.Normalize(z_min, z_max)
    cmap = cm.get_cmap('jet')  # Spectral
    colors = cmap(norm(dz))

    if ax is None:
        fig = plt.figure()
        ax = Axes3D(fig, azim=-35, elev=35)

    ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors)

    if title and fig:
        ax.set_title(title)

    # x axis
    ax.axes.w_xaxis.set_major_locator(plt.IndexLocator(1, -0.5))
    if xlabels:
        ax.set_xticklabels(xlabels)
    ax.tick_params(axis='x', labelsize=14)

    # y axis
    ax.axes.w_yaxis.set_major_locator(plt.IndexLocator(1, -0.5))
    if ylabels:
        ax.set_yticklabels(ylabels)
    ax.tick_params(axis='y', labelsize=14)

    # z axis
    ax.axes.w_zaxis.set_major_locator(plt.IndexLocator(1, 0.5))
    ax.set_zlim3d([min(z_min, 0), z_max])

    # color axis
    if colorbar:
        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75, pad=.0)
        cb1 = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)

    return fig, ax
Esempio n. 41
0
np.random.seed(5)

iris = datasets.load_iris()
X = iris.data
y = iris.target

estimators = [('k_means_iris_8', KMeans(n_clusters=8)),
              ('k_means_iris_3', KMeans(n_clusters=3)),
              ('k_means_iris_bad_init',
               KMeans(n_clusters=3, n_init=1, init='random'))]

fignum = 1
titles = ['8 clusters', '3 clusters', '3 clusters, bad initialization']
for name, est in estimators:
    fig = plt.figure(fignum, figsize=(4, 3))
    ax = Axes3D(fig, rect=[0, 0, .95, 1], elev=48, azim=134)
    est.fit(X)
    labels = est.labels_

    ax.scatter(X[:, 3],
               X[:, 0],
               X[:, 2],
               c=labels.astype(np.float),
               edgecolor='k')

    ax.w_xaxis.set_ticklabels([])
    ax.w_yaxis.set_ticklabels([])
    ax.w_zaxis.set_ticklabels([])
    ax.set_xlabel('Petal width')
    ax.set_ylabel('Sepal length')
    ax.set_zlabel('Petal length')
Esempio n. 42
0
    def contour_plot(self,
                     data=None,
                     labels=None,
                     interval=0.2,
                     title="adaboost",
                     name=None,
                     make_gif=False,
                     mode="3d"):
        if data is None:
            data = self.X
            labels = self.y
        if labels is None:
            labels = np.ones([len(data)])
        x_min, x_max = data[:, 0].min() - .5, data[:, 0].max() + .5
        y_min, y_max = data[:, 1].min() - .5, data[:, 1].max() + .5
        #xx, yy, Z_grid are used for plotting surface
        xx, yy = np.meshgrid(np.arange(x_min, x_max, interval),
                             np.arange(y_min, y_max, interval))
        X_grid = np.concatenate([
            np.expand_dims(np.ravel(xx), axis=-1),
            np.expand_dims(np.ravel(yy), axis=-1)
        ],
                                axis=-1)

        Z_grid = self.predict(data=X_grid, reduction="mean")
        Z_grid = Z_grid.reshape(xx.shape)
        if mode == "3d":
            fig = plt.figure()
            ax = Axes3D(fig)
            ax.set_zlim(Z_grid.min() * 1.1, Z_grid.max() * 1.1)
            ax.view_init(azim=120)
            plt.title(title)
            ax.plot_surface(xx, yy, Z_grid, cmap=plt.cm.summer, alpha=0.6)
            ax.scatter(xs=data[labels == 1][:, 0],
                       ys=data[labels == 1][:, 1],
                       zs=self.predict(data=data,
                                       reduction="mean")[labels == 1],
                       c='#00CED1')
            ax.scatter(xs=data[labels == -1][:, 0],
                       ys=data[labels == -1][:, 1],
                       zs=self.predict(data=data,
                                       reduction="mean")[labels == -1],
                       c='#DC143C')
            if not os.path.exists('temp'):
                os.mkdir('temp')
            if name is None:
                plt.savefig(title + '.png')
                plt.close()
            else:
                plt.savefig('temp/' + name + '.png')
                plt.close()

        if mode == "2d":
            plt.contourf(xx, yy, Z_grid, cmap=plt.cm.RdBu, alpha=.8)
            plt.scatter(data[:, 0],
                        data[:, 1],
                        c=labels,
                        cmap=ListedColormap(['#FF0000', '#0000FF']),
                        edgecolors='k')
            plt.title(title)
            if name is None:
                plt.savefig(title + '.png')
                plt.close()
            else:
                plt.savefig('temp/' + name + '.png')
                plt.close()
        if make_gif == True:
            imgs = []
            for i in range(len(os.listdir('temp'))):
                imgs.append(imageio.imread('temp/' + str(i + 1) + '.png'))
            imageio.mimsave('AdaBoost.gif', imgs, 'GIF', duration=0.1)
Esempio n. 43
0
def matrix_histogram_complex(M,
                             xlabels=None,
                             ylabels=None,
                             title=None,
                             limits=None,
                             phase_limits=None,
                             colorbar=True,
                             fig=None,
                             ax=None,
                             threshold=None):
    """
    Draw a histogram for the amplitudes of matrix M, using the argument
    of each element for coloring the bars, with the given x and y labels
    and title.

    Parameters
    ----------
    M : Matrix of Qobj
        The matrix to visualize

    xlabels : list of strings
        list of x labels

    ylabels : list of strings
        list of y labels

    title : string
        title of the plot (optional)

    limits : list/array with two float numbers
        The z-axis limits [min, max] (optional)

    phase_limits : list/array with two float numbers
        The phase-axis (colorbar) limits [min, max] (optional)

    ax : a matplotlib axes instance
        The axes context in which the plot will be drawn.

    threshold: float (None)
        Threshold for when bars of smaller height should be transparent. If
        not set, all bars are colored according to the color map.

    Returns
    -------
    fig, ax : tuple
        A tuple of the matplotlib figure and axes instances used to produce
        the figure.

    Raises
    ------
    ValueError
        Input argument is not valid.

    """

    if isinstance(M, Qobj):
        # extract matrix data from Qobj
        M = M.full()

    n = np.size(M)
    xpos, ypos = np.meshgrid(range(M.shape[0]), range(M.shape[1]))
    xpos = xpos.T.flatten() - 0.5
    ypos = ypos.T.flatten() - 0.5
    zpos = np.zeros(n)
    dx = dy = 0.8 * np.ones(n)
    Mvec = M.flatten()
    dz = abs(Mvec)

    # make small numbers real, to avoid random colors
    idx, = np.where(abs(Mvec) < 0.001)
    Mvec[idx] = abs(Mvec[idx])

    if phase_limits:  # check that limits is a list type
        phase_min = phase_limits[0]
        phase_max = phase_limits[1]
    else:
        phase_min = -pi
        phase_max = pi

    norm = mpl.colors.Normalize(phase_min, phase_max)
    cmap = complex_phase_cmap()

    colors = cmap(norm(angle(Mvec)))
    if threshold is not None:
        colors[:, 3] = 1 * (dz > threshold)

    if ax is None:
        fig = plt.figure()
        ax = Axes3D(fig, azim=-35, elev=35)

    ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=colors)

    if title and fig:
        ax.set_title(title)

    # x axis
    ax.axes.w_xaxis.set_major_locator(plt.IndexLocator(1, -0.5))
    if xlabels:
        ax.set_xticklabels(xlabels)
    ax.tick_params(axis='x', labelsize=12)

    # y axis
    ax.axes.w_yaxis.set_major_locator(plt.IndexLocator(1, -0.5))
    if ylabels:
        ax.set_yticklabels(ylabels)
    ax.tick_params(axis='y', labelsize=12)

    # z axis
    if limits and isinstance(limits, list):
        ax.set_zlim3d(limits)
    else:
        ax.set_zlim3d([0, 1])  # use min/max
    # ax.set_zlabel('abs')

    # color axis
    if colorbar:
        cax, kw = mpl.colorbar.make_axes(ax, shrink=.75, pad=.0)
        cb = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
        cb.set_ticks([-pi, -pi / 2, 0, pi / 2, pi])
        cb.set_ticklabels(
            (r'$-\pi$', r'$-\pi/2$', r'$0$', r'$\pi/2$', r'$\pi$'))
        cb.set_label('arg')

    return fig, ax
Esempio n. 44
0
def plot_3D(data):
	fig = plt.figure()
	ax = fig.add_subplot(111, projection='3d')
	Axes3D.scatter(ax,data[:,0],data[:,1],data[:,2])
	ax.view_init(azim=160)
	plt.show()
Esempio n. 45
0
        self.b_2 += -0.5*b2

# --- Dane ---
X = [] 
X.append(rand(100)*6 - 3)
X.append(rand(100)*4 - 1)
X = np.matrix(X)
Y = np.sin(2 * X[0] + X[1])

# --- Uczenie sieci na 100000 iteracji ---
N= Neuron()  
blad= []
for i in range(10000):
    blad.append(np.sum(((N.impuls(X)-Y)@(N.impuls(X)-Y).T)))
    N.aktualizacja_wag(X,Y)

plt.plot(blad)

x1 = np.linspace(-3 ,3, 50)
y1 = np.linspace(-1 ,3, 50)
x1, y1 = np.meshgrid(x1,y1)
z =  np.sin(2*x1 + y1)to 

H = Axes3D(plt.figure(1))

H.plot_surface(x1 , y1, z , cmap = 'Greens' ,alpha=0.8)
H.scatter(X[0],X[1],N.impuls(X),c='red',marker='^')
plt.show()
        
    
    
Esempio n. 46
0
gamma2 = 0.2  # qubit dephasing rate
# initial state
a = 1.0
psi0 = (a * basis(2, 0) + (1 - a) * basis(2, 1)) / (sqrt(a**2 + (1 - a)**2))
tlist = linspace(0, 4, 250)
sx, sy, sz = qubit_integrate(w, theta, gamma1, gamma2, psi0, tlist)

## animate the dynamics on the Bloch sphere

from pylab import *

import matplotlib.animation as animation
from mpl_toolkits.mplot3d import Axes3D

fig = figure()
ax = Axes3D(fig, azim=-40, elev=30)
sphere = Bloch(axes=ax)


def animate(i):
    sphere.clear()
    sphere.add_vectors([sin(theta), 0, cos(theta)])
    sphere.add_points([sx[:i + 1], sy[:i + 1], sz[:i + 1]])
    sphere.make_sphere()
    return ax


def init():
    sphere.vector_color = ['r']
    return ax
Esempio n. 47
0
def plot_attractor(steps=15000,
                   dt=0.001,
                   attractor='lorenz',
                   random=True,
                   color='b'):
    """
    Plots a the chosen attractor
    :param steps: timesteps to integrate
    :param dt: delta t
    :param attractor: type of attractor
    :return:
    """
    # Need one more for the initial values
    xo_vals = np.empty(steps)
    yo_vals = np.empty(steps)
    zo_vals = np.empty(steps)
    xo_dot = 0
    yo_dot = 0
    zo_dot = 0
    if random:

        if attractor == 'lorenz':
            xo_vals[0], yo_vals[0], zo_vals[0] = init_random(x_variance=20.0,
                                                             y_variance=20.0,
                                                             z_variance=20.0)
        elif attractor == 'rossler':
            xo_vals[0], yo_vals[0], zo_vals[0] = init_random(x_variance=10.0,
                                                             y_variance=10.0,
                                                             z_variance=10.0)
        elif attractor == 'chua':
            xo_vals[0], yo_vals[0], zo_vals[0] = init_random(x_variance=2.0,
                                                             y_variance=0.5,
                                                             z_variance=2.0)
        else:
            log.out.error("Attractor: " + attractor + " not defined.")
            sys.exit(-1)
    else:
        if attractor == 'lorenz':
            xo_vals[0] = 1.0
            yo_vals[0] = 1.0
            zo_vals[0] = 1.0
        elif attractor == 'rossler':
            xo_vals[0] = 1.0
            yo_vals[0] = 1.0
            zo_vals[0] = 1.0
        elif attractor == 'chua':
            xo_vals[0] = 0.777
            yo_vals[0] = -0.222
            zo_vals[0] = -1.222
        else:
            log.out.error("Attractor: " + attractor + " not defined.")
            sys.exit(-1)

    # Stepping through time
    for i in range(0, steps - 1):
        # Calculate the derivatives of the X, Y, Z state
        if attractor == 'lorenz':
            xo_dot, yo_dot, zo_dot = lorenz(xo_vals[i], yo_vals[i], zo_vals[i])
        elif attractor == 'rossler':
            xo_dot, yo_dot, zo_dot = rossler(xo_vals[i], yo_vals[i],
                                             zo_vals[i])
        elif attractor == 'chua':
            xo_dot, yo_dot, zo_dot = chua(xo_vals[i], yo_vals[i], zo_vals[i])

        # Propagate the system
        xo_vals[i + 1] = xo_vals[i] + (xo_dot * dt)
        yo_vals[i + 1] = yo_vals[i] + (yo_dot * dt)
        zo_vals[i + 1] = zo_vals[i] + (zo_dot * dt)

    fig3d = plt.figure()
    fig3d.canvas.set_window_title('3D View (model)')
    ax3d = Axes3D(fig3d)
    ax3d.plot(xo_vals, yo_vals, zo_vals, color=color, linewidth=0.5)
    ax3d.set_xlabel("X Axis")
    ax3d.set_ylabel("Y Axis")
    ax3d.set_zlabel("Z Axis")
    if attractor == 'lorenz':
        ax3d.set_title("Lorenz Attractor")
    elif attractor == 'rossler':
        ax3d.set_title("Rössler Attractor")
    elif attractor == 'chua':
        ax3d.set_title("Chua's Circuit Attractor")

    plt.show()
Esempio n. 48
0
    return k*cm.exp(1j*b*t*t)
def signal_u2(t):
    return k*cm.exp(-1j*b*t*t)
def signal_u(t):
    if -T<t<T:
        return signal_u1(t)+signal_u2(t)
    else:
        return 0
def X11(t,f):
    k1 = 0.5*(1-abs(t)/T)*il.m.sin(il.m.pi*(f-b*t/il.m.pi)*(T - abs(t)))
    k2 = cm.exp(1j*(il.m.pi*f*(T+t)-b*t*T))
    if (il.m.pi*(f-b*t/il.m.pi)*(T - abs(t)))==0:
        return 1
    else:
        return k1*k2/(il.m.pi*(f-b*t/il.m.pi)*(T - abs(t)))
def X22(t,f):
    return X11(t,-f)*cm.exp(1j*2*il.m.pi*f*t)
def Lchm_V(t,f):
    return X11(t,f) + X22(t,f)
    
if __name__ == "__main__":
    time = [t for t in il.np.arange(-6,6,100*T)]
    freq = [f for f in il.np.arange(-2e3,2e3,1/T)]
    xgrid, ygrid = il.np.meshgrid(time, freq)
    Z = [[abs(Lchm_V(t,f)) for t in time ] for f in freq]
    import pylab
    from mpl_toolkits.mplot3d import Axes3D
    fig = pylab.figure()
    axes = Axes3D(fig)
    axes.plot_surface(xgrid, ygrid,Z, rstride=1, cstride=1)
    pylab.show()
Esempio n. 49
0
model.score(X, y) # is the R2 score for full model


## Creating testing and training data
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 42, stratify = y) # The stratify means that the testing data and training 
#data will contain the same ratio. For instance, if the training data is 60% female, the testing data will also be 60% female.


## Multiple Linear Regression
from sklearn.datasets import make_regression
X, y = make_regression(n_samples=30, n_features=3, n_informative=3, random_state=42, noise = 0.5, bias = 100)
    # To visualize on a 3 D plot
from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure(1, figsize=(5,5))
axes = Axes3D(fig, elev=20, azim=45)
axes.scatter(X[:,0], X[:,1], X[:,2], c=y, cmap=plt.cm.get_cmap("Spectra"))
plt.show
    # Can still fit model as normal (The Linear Regression model in sklearn uses the Ordinary Least Squares method)
model = LinearRegression()
model.fit(X, y)  # to fit against the 3D dataset.


##To plot residuals
predictions = model.predict(X)
plt.scatter(predictions, predictions - y)
plt.hlines(y=0, xmin=predictions.min(), xmax=predictions.max())
plt.show()
## Data where the residuals looks random is good.  Data where the residuals follow a patter, such as a curve, suggest we're missing something in our training
##Example code (from class) on charting the residuals for training and testing data on the same plot.
plt.scatter(model.predict(X_train), model.predict(X_train - y_train), c="blue")
Esempio n. 50
0
def plot_mag_3d(measured, calibrated, p):
    # set up points for sphere and ellipsoid wireframes
    u = r_[0:2 * pi:20j]
    v = r_[0:pi:20j]
    wx = outer(cos(u), sin(v))
    wy = outer(sin(u), sin(v))
    wz = outer(ones(size(u)), cos(v))
    ex = p[0] * ones(size(u)) + outer(cos(u), sin(v)) / p[3]
    ey = p[1] * ones(size(u)) + outer(sin(u), sin(v)) / p[4]
    ez = p[2] * ones(size(u)) + outer(ones(size(u)), cos(v)) / p[5]

    # measurements
    mx = measured[:, 0]
    my = measured[:, 1]
    mz = measured[:, 2]
    m_max = amax(abs(measured))

    # calibrated values
    cx = calibrated[:, 0]
    cy = calibrated[:, 1]
    cz = calibrated[:, 2]

    # axes size
    left = 0.02
    bottom = 0.05
    width = 0.46
    height = 0.9
    rect_l = [left, bottom, width, height]
    rect_r = [left / 2 + 0.5, bottom, width, height]

    fig = figure(figsize=figaspect(0.5))
    if matplotlib.__version__.startswith('0'):
        ax = Axes3D(fig, rect=rect_l)
    else:
        ax = fig.add_subplot(1, 2, 1, position=rect_l, projection='3d')
    # plot measurements
    ax.scatter(mx, my, mz)
    hold(True)
    # plot line from center to ellipsoid center
    ax.plot([0.0, p[0]], [0.0, p[1]], [0.0, p[2]], color='black', marker='+')
    # plot ellipsoid
    ax.plot_wireframe(ex, ey, ez, color='grey', alpha=0.5)

    ax.set_title('MAG raw with fitted ellipsoid and center offset')
    ax.set_xlabel('x')
    ax.set_ylabel('y')
    ax.set_zlabel('z')
    ax.set_xlim3d(-m_max, m_max)
    ax.set_ylim3d(-m_max, m_max)
    ax.set_zlim3d(-m_max, m_max)

    if matplotlib.__version__.startswith('0'):
        ax = Axes3D(fig, rect=rect_r)
    else:
        ax = fig.add_subplot(1, 2, 2, position=rect_r, projection='3d')
    ax.plot_wireframe(wx, wy, wz, color='grey', alpha=0.5)
    hold(True)
    ax.scatter(cx, cy, cz)

    ax.set_title('MAG calibrated on unit sphere')
    ax.set_xlabel('x')
    ax.set_ylabel('y')
    ax.set_zlabel('z')
    ax.set_xlim3d(-1, 1)
    ax.set_ylim3d(-1, 1)
    ax.set_zlim3d(-1, 1)
    show()
Esempio n. 51
0
    def __init__(self):
        super(MainWindow, self).__init__()

        self.expression_index = 0
        self.point_index = 0
        self.size = 0
        self.current_full_filename = ''
        self.current_filename = ''
        self.limits = 96

        self.x_ = []
        self.y_ = []
        self.z_ = []
        self.head_data = ()
        self.head_data_copy = ()

        self.setFixedSize(800, 600)
        self.setWindowTitle('HeadEditor')
        self.center()

        main_layout = QtGui.QHBoxLayout()
        layout_left = QtGui.QVBoxLayout()

        self.figure = matplotlib.figure.Figure()  # Plot
        self.canvas = FigureCanvas(self.figure)
        self.axes = Axes3D(self.figure)

        group_box = QGroupBox("Editing:")

        self.cb = QComboBox()
        self.cb.currentIndexChanged.connect(self.select_change)

        slider_lim = 128
        slider_interval = 32

        self.x_slider = QSlider(Qt.Horizontal)
        self.x_slider.valueChanged.connect(self.x_slider_change)
        self.x_slider.setMinimum(-slider_lim)
        self.x_slider.setMaximum(slider_lim)
        self.x_slider.setTickPosition(QSlider.TicksBelow)
        self.x_slider.setTickInterval(slider_interval)
        self.x_slider.setEnabled(False)

        self.y_slider = QSlider(Qt.Horizontal)
        self.y_slider.valueChanged.connect(self.y_slider_change)
        self.y_slider.setMinimum(-slider_lim)
        self.y_slider.setMaximum(slider_lim)
        self.y_slider.setTickPosition(QSlider.TicksBelow)
        self.y_slider.setTickInterval(slider_interval)
        self.y_slider.setEnabled(False)

        self.z_slider = QSlider(Qt.Horizontal)
        self.z_slider.valueChanged.connect(self.z_slider_change)
        self.z_slider.setMinimum(-slider_lim)
        self.z_slider.setMaximum(slider_lim)
        self.z_slider.setTickPosition(QSlider.TicksBelow)
        self.z_slider.setTickInterval(slider_interval)
        self.z_slider.setEnabled(False)

        self.expression_slider = QSlider(Qt.Horizontal)
        self.expression_slider.valueChanged.connect(
            self.expression_slider_change)
        self.expression_slider.setMinimum(0)
        self.expression_slider.setMaximum(4)
        self.expression_slider.setValue(0)
        self.expression_slider.setTickPosition(QSlider.TicksBelow)
        self.expression_slider.setTickInterval(1)
        self.expression_slider.setEnabled(False)

        self.load_button = QtGui.QPushButton('Load', self)
        self.load_button.clicked.connect(self.load_data)

        self.save_button = QtGui.QPushButton('Save', self)
        self.save_button.clicked.connect(self.save_data)

        self.x_slider_label = QLabel("x : 0")
        self.y_slider_label = QLabel("y : 0")
        self.z_slider_label = QLabel("z : 0")
        self.exp_slider_label = QLabel("Expression : 1")

        hbox = QVBoxLayout()
        hbox.addWidget(self.x_slider_label)
        hbox.addWidget(self.x_slider)
        hbox.addWidget(self.y_slider_label)
        hbox.addWidget(self.y_slider)
        hbox.addWidget(self.z_slider_label)
        hbox.addWidget(self.z_slider)
        hbox.addWidget(self.exp_slider_label)
        hbox.addWidget(self.expression_slider)
        hbox.addWidget(self.load_button)
        hbox.addWidget(self.save_button)
        hbox.addStretch(1)

        allitems = QVBoxLayout()
        allitems.addWidget(self.cb)
        allitems.addLayout(hbox)

        group_box.setLayout(allitems)

        layout_left.addWidget(self.canvas)

        main_layout.addLayout(layout_left)
        main_layout.addWidget(group_box)
        self.setLayout(main_layout)

        self.axes.view_init(20, 60)
        self.plot_3d()
Esempio n. 52
0
%matplotlib notebook

from sklearn import linear_model
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

X = np.array([[0, 0], [1,2], [2,4], [3,0], [4,1]])
y = np.array([0, 0.3, 0.75, 1, 2])

lin_regr = linear_model.LinearRegression()
lin_regr.fit(X, y)

fig = plt.figure(figsize=(6, 5))
ax = Axes3D(fig, elev=45, azim=-120)
ax.scatter(X[:, 0], X[:, 1], y, c='r', marker='o', label='training set')
ax.plot_surface(np.array([[-1, -1], [5, 5]]), np.array([[-1, 5], [-1, 5]]), lin_regr.predict(np.array([[-1, -1, 5, 5], [-1, 5, -1, 5]]).T).reshape((2, 2)), alpha=.5, label='linear regression predictor')
ax.set_xlabel('input X_1')
ax.set_ylabel('input X_2')
ax.set_zlabel('output Y')
plt.title("Simplistic test of linear regression on 2d input")
plt.show()
Esempio n. 53
0
y_train = np.loadtxt(y_train_file_file)
y_final_test = np.loadtxt(y_final_test_file)
activity_labels = np.loadtxt(activity_labels_file, dtype=str)

X_train_file.close()
X_final_test_file.close()
y_train_file_file.close()
y_final_test_file.close()
activity_labels_file.close()

k_means = cluster.KMeans(n_clusters=6)
km = k_means.fit(X_train)
labels = km.predict(X_final_test)

fig1 = plt.figure(1, figsize=(10, 8))
ax = Axes3D(fig1, rect=[0, 0, .95, 1], elev=48, azim=134)

ax.scatter(X_final_test[:, 0],
           X_final_test[:, 40],
           X_final_test[:, 80],
           c=labels.astype(np.float),
           edgecolor='k')

ax.w_xaxis.set_ticklabels([])
ax.w_yaxis.set_ticklabels([])
ax.w_zaxis.set_ticklabels([])
ax.set_xlabel('tBodyAcc-XYZ')
ax.set_ylabel('tGravityAcc-XYZ')
ax.set_zlabel('tBodyAccJerk-XYZ')
ax.set_title("6 Clusters")
ax.dist = 10
def graph():
    # 连接数据库
    conn = mdb.connect(host='127.0.0.1',
                       port=3306,
                       user='******',
                       passwd='root',
                       db='alibaba_trace',
                       charset='utf8')

    # 如果使用事务引擎,可以设置自动提交事务,或者在每次操作完成后手动提交事务conn.commit()
    conn.autocommit(1)  # conn.autocommit(True)

    # 使用cursor()方法获取操作游标
    cursor = conn.cursor()
    # 因该模块底层其实是调用CAPI的,所以,需要先得到当前指向数据库的指针。

    try:
        # 查询数据条目
        job_duration = cursor.execute(
            "SELECT max(end_timestamp) - min(start_timestamp) FROM batch_instance WHERE status = 'Terminated'  and real_mem_avg != 0  group by job_id ASC "
        )
        job_duration = cursor.fetchall()
        list_job_duration = list(job_duration)
        arr_job_duration = [x[0] for x in list_job_duration]
        print(arr_job_duration)
        arr_job_duration_norm = MaxMinNormalization(arr_job_duration,
                                                    max(arr_job_duration),
                                                    min(arr_job_duration))

        cursor.execute(
            "select t.job_id, avg(t.avg_cpu), avg(t.avg_mem) from (select job_id, task_id, avg(real_cpu_avg) as avg_cpu, avg(real_mem_avg) as avg_mem from batch_instance where status='Terminated' and real_mem_avg != 0 group by task_id )t group by job_id ASC"
        )
        # cursor.execute("select t.job_id, avg(t.avg_cpu), avg(t.avg_mem) from (select job_id, task_id, avg(cpu) as avg_cpu, avg(mem) as avg_mem from test  group by task_id )t group by job_id ")
        records = cursor.fetchall()
        list_records = list(records)
        res = []
        res[:] = map(list, list_records)

        job_arr = [x[0] for x in res]
        cpu_arr = [x[1] for x in res]
        print(cpu_arr)
        cpu_arr_norm = MaxMinNormalization(cpu_arr, max(cpu_arr), min(cpu_arr))
        mem_arr = [x[2] for x in res]
        print(mem_arr)
        mem_arr_norm = MaxMinNormalization(mem_arr, max(mem_arr), min(cpu_arr))

        # 如果没有设置自动提交事务,则这里需要手动提交一次
        conn.commit()

        # k-means聚类
        # 设置类别为3
        clf = KMeans(n_clusters=3)
        # 将数据带入到聚类模型中
        loan = []
        loan.append(arr_job_duration_norm)
        loan.append(cpu_arr_norm)
        loan.append(mem_arr_norm)
        loan = np.asarray(loan)
        loan = loan.transpose()

        clf = clf.fit(loan)
        loan = np.insert(loan, 3, values=clf.labels_, axis=1)

        fig = plt.figure()
        ax = Axes3D(fig)
        loan_df = pd.DataFrame(loan)
        class_1 = loan_df[loan_df.iloc[:, 3] == 0]
        print('class_1:')
        print(class_1)
        x1 = class_1.iloc[:, 0].values
        y1 = class_1.iloc[:, 1].values
        z1 = class_1.iloc[:, 2].values
        class_2 = loan_df[loan_df.iloc[:, 3] == 1]
        x2 = class_2.iloc[:, 0].values
        y2 = class_2.iloc[:, 1].values
        z2 = class_2.iloc[:, 2].values
        print("class_2:")
        print(class_2)
        class_3 = loan_df[loan_df.iloc[:, 3] == 2]
        x3 = class_3.iloc[:, 0].values
        y3 = class_3.iloc[:, 1].values
        z3 = class_3.iloc[:, 2].values
        print("class_3")
        print(class_3)
        ax.scatter(x1, y1, z1, color='red', s=1)
        ax.scatter(x2, y2, z2, color='blue', s=1)
        ax.scatter(x3, y3, z3, color='yellow', s=1)

        ax.set_xlabel('job duration')
        ax.set_ylabel('average cpu(per job)')
        ax.set_zlabel('average memory(per job)')
        ax.set_xlim(0, 1)
        ax.view_init(elev=20., azim=-35)
        ax.grid(False)
        plt.savefig('../imgs_mysql/knn_job.png')
        plt.show()

    except:
        import traceback
        traceback.print_exc()
        # 发生错误时回滚
        conn.rollback()
    finally:
        # 关闭游标连接
        cursor.close()
        # 关闭数据库连接
        conn.close()
Esempio n. 55
0
#call the animator.  blit=True means only re-draw the parts that have changed.
anim = animation.FuncAnimation(fig,
                               animate,
                               frames=time,
                               interval=10,
                               blit=False)
anim.save('dynamic_images3.gif', fps=60)

plt.show()

T_list = np.array(T_list)

from mpl_toolkits.mplot3d import Axes3D

fig2 = plt.figure(figsize=(10, 10))
ax2 = Axes3D(fig2)
ax2.set_title('Heat Simulation 0.0s', fontsize=30)

ax2.plot_surface(X,
                 Y,
                 T_list[0],
                 rstride=1,
                 cstride=1,
                 vmin=min(U),
                 vmax=max(U),
                 cmap='hot')
ax2.contourf(X,
             Y,
             T_list[0],
             zdir='z',
             offset=min(U),
Esempio n. 56
0
ols_trainX1 = trainX1.copy()
ols_trainX1 = sm.add_constant(ols_trainX1)

est = sm.OLS(trainY, ols_trainX1).fit()
est.summary()

# %% 3D Plot

x0 = ols_trainX1.T[0]
x1 = ols_trainX1.T[1]

Z = est.params[0] + est.params[1] * x0 + est.params[2] * x1

fig = plt.figure(figsize=(12, 8))
ax = Axes3D(fig, azim=-115, elev=15)
#ax = fig.add_subplot(111, projection='3d')

x0 = ols_trainX1.T[0]
x1 = ols_trainX1.T[1]
xx0, xx1 = np.meshgrid(np.linspace(x0.min(), x0.max(), len(x0)),
                       np.linspace(x1.min(), x1.max(), len(x1)))

Z0 = est.params[0] + est.params[1] * xx0 + est.params[2] * xx1
Z1 = est.params[0] + est.params[1] * x0 + est.params[2] * x1
surf = ax.plot_surface(xx0, xx1, Z1, cmap=plt.cm.RdBu_r, alpha=.1, linewidth=0)

resid = trainY.T[0] - est.predict(ols_trainX1)
ax.scatter(x0[resid >= 0],
           x1[resid >= 0],
           trainY[resid >= 0],
Esempio n. 57
0
def run():

    # Configure parameters
    N = 10  # number of cavity fock states
    wc = 2 * pi * 1.0  # cavity frequency
    wa = 2 * pi * 1.0  # atom frequency
    g = 2 * pi * 0.1  # coupling strength
    kappa = 0.05  # cavity dissipation rate
    gamma = 0.15  # atom dissipation rate
    use_rwa = True

    # a coherent initial state the in cavity
    psi0 = tensor(coherent(N, 1.5), basis(2, 0))

    # Hamiltonian
    a = tensor(destroy(N), qeye(2))
    sm = tensor(qeye(N), destroy(2))

    if use_rwa:
        # use the rotating wave approxiation
        H = wc * a.dag() * a + wa * sm.dag() * sm + g * (a.dag() * sm +
                                                         a * sm.dag())
    else:
        H = wc * a.dag() * a + wa * sm.dag() * sm + g * (a.dag() +
                                                         a) * (sm + sm.dag())

    # collapse operators
    c_op_list = []

    n_th_a = 0.0  # zero temperature
    rate = kappa * (1 + n_th_a)
    if rate > 0.0:
        c_op_list.append(sqrt(rate) * a)

    rate = kappa * n_th_a
    if rate > 0.0:
        c_op_list.append(sqrt(rate) * a.dag())

    rate = gamma
    if rate > 0.0:
        c_op_list.append(sqrt(rate) * sm)

    # evolve the system
    tlist = linspace(0, 10, 100)
    output = mesolve(H, psi0, tlist, c_op_list, [])

    # calculate the wigner function
    xvec = linspace(-5., 5., 100)
    X, Y = meshgrid(xvec, xvec)

    #for idx, rho in enumerate(output.states): # suggestion: try to loop over all rho
    for idx, rho in enumerate([output.states[44]
                               ]):  # for a selected time t=4.4

        rho_cavity = ptrace(rho, 0)
        W = wigner(rho_cavity, xvec, xvec)

        # plot the wigner function
        fig = figure(figsize=(9, 6))
        ax = Axes3D(fig, azim=-107, elev=49)
        ax.set_xlim3d(-5, 5)
        ax.set_ylim3d(-5, 5)
        ax.set_zlim3d(-0.30, 0.30)
        surf = ax.plot_surface(X,
                               Y,
                               W,
                               rstride=1,
                               cstride=1,
                               cmap=cm.jet,
                               alpha=1.0,
                               linewidth=0.05,
                               vmax=0.4,
                               vmin=-0.4)
        fig.colorbar(surf, shrink=0.65, aspect=20)
        #savefig("jc_model_wigner_"+str(idx)+".png")

    show()
Esempio n. 58
0
def dbscan():
    data = a
    sse = []
    ch = []
    sc = []
    purity = []
    nmi = []
    ari = []
    xs = []
    ys = []
    zs = []

    labels_true = [1, 1, 1, 0, 0, 0, 1, 1]  # 实际分类
    epsmax = 13
    minspmax = 4

    for ms in range(1, minspmax):
        for e in range(2, epsmax):
            xs.append(ms)  #建立x数列
            ys.append(e)  #建立y数列
            #开始分类
            db = DBSCAN(eps=e, min_samples=ms,
                        metric='euclidean')  #esp聚类半径,min半径内最少点数,metric距离
            predict = db.fit_predict(data)
            print(predict)  #打印分类结果
            labels = db.labels_
            print('labels=', labels)
            #可视化结果
            purity.append(ACC(labels_true, predict))
            # 设计算NMI
            nmi.append(
                metrics.normalized_mutual_info_score(labels_true, predict))
            # 计算ARI
            ari.append(metrics.adjusted_rand_score(labels_true, predict))
            # 计算CH系数 轮廓系数
            ch.append(metrics.calinski_harabasz_score(data, labels))
            sc.append(
                metrics.silhouette_score(
                    data, labels, metric='euclidean'))  # 此处算法一定要与上面ag中的算法一致

    print('min_samples:', xs)
    print('eps:', ys)
    print('SC:', sc)
    print('CH:', ch)
    print('purity:', purity)
    print('NMI:', nmi)
    print('ARI:', ari)

    #开始绘图
    #绘制min_samples-esp-SC图
    fig = plt.figure()  # 创建一个画布figure,然后在这个画布上加各种元素。
    ax = Axes3D(fig)  # 将画布作用于 Axes3D 对象上。
    # 基于ax变量绘制三维图
    # xs表示x方向的变量
    # ys表示y方向的变量
    # zs表示z方向的变量,这三个方向上的变量都可以用list的形式表示
    # m表示点的形式,o是圆形的点,^是三角形(marker)
    # c表示颜色(color for short)
    ax.plot(xs, ys, sc, c='r', marker='X', label='Silhouette Score')  # 点为红色三角形

    # 显示图例
    ax.legend()
    # 设置坐标轴
    plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
    ax.set_xlabel('min samples')
    ax.set_ylabel('eps')
    ax.set_zlabel('Silhouette Score')
    ax.set_title('min_samples-eps-SC for JDD')
    for x, y, z in zip(xs, ys, sc):
        ax.text(x,
                y,
                z,
                str(np.around(z, 2)),
                ha='center',
                va='bottom',
                fontsize=8.5)
    # 显示图形
    plt.show()

    # 绘制min_samples-esp-ch图
    fig = plt.figure()  # 创建一个画布figure,然后在这个画布上加各种元素。
    ax = Axes3D(fig)  # 将画布作用于 Axes3D 对象上。
    ax.plot(xs, ys, ch, c='r', marker='o', label='Calinski-Harabasz')
    # 显示图例
    ax.legend()
    # 设置坐标轴
    plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
    ax.set_xlabel('min samples')
    ax.set_ylabel('eps')
    ax.set_zlabel('Calinski-Harabasz')
    ax.set_title('min_samples-eps-ch for JDD')
    for x, y, z in zip(xs, ys, ch):
        ax.text(x,
                y,
                z,
                str(np.around(z, 2)),
                ha='center',
                va='bottom',
                fontsize=8.5)
    # 显示图形
    plt.show()

    # 绘制min_samples-eps-purity图
    fig = plt.figure()  # 创建一个画布figure,然后在这个画布上加各种元素。
    ax = Axes3D(fig)  # 将画布作用于 Axes3D 对象上。
    ax.plot(xs, ys, purity, c='r', marker='o', label='purity')  # 点为红色圆形
    # 显示图例
    ax.legend()
    # 设置坐标轴
    plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
    ax.set_xlabel('min samples')
    ax.set_ylabel('eps')
    ax.set_zlabel('purity')
    ax.set_title('min_samples-eps-purity for JDD')
    for x, y, z in zip(xs, ys, purity):
        ax.text(x,
                y,
                z,
                str(np.around(z, 2)),
                ha='center',
                va='bottom',
                fontsize=8.5)
    # 显示图形
    plt.show()

    # 绘制min_samples-eps-NMI图
    fig = plt.figure()  # 创建一个画布figure,然后在这个画布上加各种元素。
    ax = Axes3D(fig)  # 将画布作用于 Axes3D 对象上。
    ax.plot(xs, ys, nmi, c='r', marker='*', label='NMI')  # 点为红色*形
    # 显示图例
    ax.legend()
    # 设置坐标轴
    plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
    ax.set_xlabel('min samples')
    ax.set_ylabel('eps')
    ax.set_zlabel('NMI')
    ax.set_title('min_samples-eps-NMI for JDD')
    for x, y, z in zip(xs, ys, nmi):
        ax.text(x,
                y,
                z,
                str(np.around(z, 2)),
                ha='center',
                va='bottom',
                fontsize=8.5)
    # 显示图形
    plt.show()

    # 绘制min_samples-eps-ARI图
    fig = plt.figure()  # 创建一个画布figure,然后在这个画布上加各种元素。
    ax = Axes3D(fig)  # 将画布作用于 Axes3D 对象上。
    ax.plot(xs, ys, ari, c='r', marker='X', label='ARI')  # 点为红色X形
    # 显示图例
    ax.legend()
    # 设置坐标轴
    plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
    ax.set_xlabel('min samples')
    ax.set_ylabel('eps')
    ax.set_zlabel('ARI')
    ax.set_title('min_samples-eps-ARI for JDD')
    for x, y, z in zip(xs, ys, ari):
        ax.text(x,
                y,
                z,
                str(np.around(z, 2)),
                ha='center',
                va='bottom',
                fontsize=8.5)
    # 显示图形
    plt.show()
from mpl_toolkits.mplot3d import Axes3D
from sklearn.decomposition import FastICA
from sklearn.random_projection import GaussianRandomProjection
from sklearn.feature_selection import VarianceThreshold


fn = "phishing_dataset.csv"
writeFn = fn[:-4] + "_vtresh_kmeans_output.csv"
print(writeFn)

norms = [True, False]
#whitens = [False,False]
#algs = ['parallel','deflation']
treshs = [0,.035,.04,.045]
fig = plot.figure(1)
ax = Axes3D(fig)

def runEverything():
    data,x,y,normx,normy = preProcessData(fn)
    results = []
    for tresh in treshs:
        for norm in norms:
            err = classify(x,y,normx,normy,tresh,norm)
            print(tresh,norm,":",err)
            results.append([tresh,norm,err])

    file = open(writeFn,"w",newline="")
    csvW = csv.writer(file)
    csvW.writerow(["tresh","norm","error"])
    csvW.writerows(results)
    print("Open your file")
def get_TPI(params, bvec1, graphs):

    start_time = time.clock()
    (S, T, beta, sigma, chi_n_vec, b_ellip, mu, l_tilde, A, alpha, delta, b_ss,
     n_ss, K_ss, C_ss, L_ss, maxiter_TPI, mindist_TPI, xi, TPI_tol,
     EulDiff) = params
    K1, K1_cnstr = fun3.get_K(bvec1)

    # Create time paths for K and L
    Kpath_init = np.zeros(T + S - 2)
    Kpath_init[:T] = get_path(K1, K_ss, T, "linear")
    Kpath_init[T:] = K_ss
    Lpath_init = L_ss * np.ones(T + S - 2)

    iter_TPI = int(0)
    dist_TPI = 10.
    Kpath_new = Kpath_init.copy()
    Lpath_new = Lpath_init.copy()
    r_params = (A, alpha, delta)
    w_params = (A, alpha)
    cbne_params = (S, T, beta, sigma, chi_n_vec, b_ellip, mu, l_tilde, bvec1,
                   b_ss, n_ss, TPI_tol, EulDiff)

    while (iter_TPI < maxiter_TPI) and (dist_TPI >= mindist_TPI):
        iter_TPI += 1
        Kpath_init = xi * Kpath_new + (1 - xi) * Kpath_init
        Lpath_init = xi * Lpath_new + (1 - xi) * Lpath_init
        rpath = fun3.get_r(r_params, Kpath_init, Lpath_init)
        wpath = fun3.get_w(w_params, Kpath_init, Lpath_init)
        cpath, bpath, npath, EulErrPath_inter, EulErrPath_intra = get_cbnepath(
            cbne_params, rpath, wpath)
        Kpath_new = np.zeros(T + S - 2)
        Kpath_new[:T], Kpath_cnstr = fun3.get_K(bpath[:, :T])
        Kpath_new[T:] = K_ss * np.ones(S - 2)
        Lpath_new[:T - 1] = fun3.get_L(npath[:, :T - 1])
        Lpath_new[T - 1:] = L_ss * np.ones(S - 1)
        Kpath_cnstr = np.append(Kpath_cnstr, np.zeros(S - 2, dtype=bool))
        Kpath_new[Kpath_cnstr] = 0.1
        dist_TPI = ((Kpath_new[1:T] - Kpath_init[1:T]) ** 2).sum() + \
            ((Lpath_new[:T] - Lpath_init[:T]) ** 2).sum()

    if iter_TPI == maxiter_TPI and dist_TPI > mindist_TPI:
        print('TPI reached maximum interation but did not converge.')

    Kpath = Kpath_new
    Lpath = Lpath_new
    Y_params = (A, alpha)
    Ypath = fun3.get_Y(Y_params, Kpath, Lpath)
    Cpath = np.zeros(T + S - 2)
    Cpath[:T - 1] = fun3.get_C(cpath[:, :T - 1])
    Cpath[T - 1:] = C_ss * np.ones(S - 1)
    RCerrPath = (Ypath[:-1] - Cpath[:-1] - Kpath[1:] +
                 (1 - delta) * Kpath[:-1])
    tpi_time = time.clock() - start_time

    tpi_output = {
        'bpath': bpath,
        'cpath': cpath,
        'npath': npath,
        'wpath': wpath,
        'rpath': rpath,
        'Kpath': Kpath,
        'Lpath': Lpath,
        'Ypath': Ypath,
        'Cpath': Cpath,
        'EulErrPath IntraTemporal': EulErrPath_intra,
        'EulErrPath InterTemporal': EulErrPath_inter,
        'RCerrPath': RCerrPath,
        'tpi_time': tpi_time
    }

    # Print TPI computation time
    fun3.print_time(tpi_time, 'TPI')

    if graphs:

        # Create directory if images directory does not already exist
        cur_path = os.path.split(os.path.abspath(__file__))[0]
        output_fldr = "images"
        output_dir = os.path.join(cur_path, output_fldr)
        if not os.access(output_dir, os.F_OK):
            os.makedirs(output_dir)

        # Plot time path of aggregate capital stock
        tvec = np.linspace(1, T + S - 2, T + S - 2)
        minorLocator = MultipleLocator(1)
        fig, ax = plt.subplots()
        plt.plot(tvec, Kpath, marker='D')
        # for the minor ticks, use no labels; default NullFormatter
        ax.xaxis.set_minor_locator(minorLocator)
        plt.grid(b=True, which='major', color='0.65', linestyle='-')
        plt.title('Time path for aggregate capital stock K')
        plt.xlabel(r'Period $t$')
        plt.ylabel(r'Aggregate capital $K_{t}$')
        output_path = os.path.join(output_dir, "Kpath")
        plt.savefig(output_path)
        plt.show()

        plt.plot(tvec, Lpath, marker='D')
        # for the minor ticks, use no labels; default NullFormatter
        ax.xaxis.set_minor_locator(minorLocator)
        plt.grid(b=True, which='major', color='0.65', linestyle='-')
        plt.title('Time path for aggregate labor supply L')
        plt.xlabel(r'Period $t$')
        plt.ylabel(r'Aggregate labor supply $L_{t}$')
        output_path = os.path.join(output_dir, "Lpath")
        plt.savefig(output_path)
        plt.show()

        # Plot time path of aggregate output (GDP)
        fig, ax = plt.subplots()
        plt.plot(tvec, Ypath, marker='D')
        # for the minor ticks, use no labels; default NullFormatter
        ax.xaxis.set_minor_locator(minorLocator)
        plt.grid(b=True, which='major', color='0.65', linestyle='-')
        plt.title('Time path for aggregate output (GDP) Y')
        plt.xlabel(r'Period $t$')
        plt.ylabel(r'Aggregate output $Y_{t}$')
        output_path = os.path.join(output_dir, "Ypath")
        plt.savefig(output_path)
        # plt.show()

        # Plot time path of aggregate consumption
        fig, ax = plt.subplots()
        plt.plot(tvec, Cpath, marker='D')
        # for the minor ticks, use no labels; default NullFormatter
        ax.xaxis.set_minor_locator(minorLocator)
        plt.grid(b=True, which='major', color='0.65', linestyle='-')
        plt.title('Time path for aggregate consumption C')
        plt.xlabel(r'Period $t$')
        plt.ylabel(r'Aggregate consumption $C_{t}$')
        output_path = os.path.join(output_dir, "C_aggr_path")
        plt.savefig(output_path)
        # plt.show()

        # Plot time path of real wage
        fig, ax = plt.subplots()
        plt.plot(tvec, wpath, marker='D')
        # for the minor ticks, use no labels; default NullFormatter
        ax.xaxis.set_minor_locator(minorLocator)
        plt.grid(b=True, which='major', color='0.65', linestyle='-')
        plt.title('Time path for real wage w')
        plt.xlabel(r'Period $t$')
        plt.ylabel(r'Real wage $w_{t}$')
        output_path = os.path.join(output_dir, "wpath")
        plt.savefig(output_path)
        # plt.show()

        # Plot time path of real interest rate
        fig, ax = plt.subplots()
        plt.plot(tvec, rpath, marker='D')
        # for the minor ticks, use no labels; default NullFormatter
        ax.xaxis.set_minor_locator(minorLocator)
        plt.grid(b=True, which='major', color='0.65', linestyle='-')
        plt.title('Time path for real interest rate r')
        plt.xlabel(r'Period $t$')
        plt.ylabel(r'Real interest rate $r_{t}$')
        output_path = os.path.join(output_dir, "rpath")
        plt.savefig(output_path)
        # plt.show()

        # Plot time path of individual savings distribution
        tgridT = np.linspace(1, T, T)
        sgrid2 = np.linspace(2, S, S - 1)
        tmatb, smatb = np.meshgrid(tgridT, sgrid2)
        cmap_bp = matplotlib.cm.get_cmap('summer')
        fig = plt.figure()
        ax = Axes3D(fig)
        #        ax = fig.gca(projection='3d')
        ax.set_xlabel(r'period-$t$')
        ax.set_ylabel(r'age-$s$')
        ax.set_zlabel(r'individual savings $b_{s,t}$')
        strideval = max(int(1), int(round(S / 10)))
        ax.plot_surface(tmatb,
                        smatb,
                        bpath[:, :T],
                        rstride=strideval,
                        cstride=strideval,
                        cmap=cmap_bp)
        output_path = os.path.join(output_dir, "bpath")
        plt.savefig(output_path)
        # plt.show()

        # Plot time path of individual consumption distribution
        tgridTm1 = np.linspace(1, T - 1, T - 1)
        sgrid = np.linspace(1, S, S)
        tmatc, smatc = np.meshgrid(tgridTm1, sgrid)
        cmap_cp = matplotlib.cm.get_cmap('summer')
        fig = plt.figure()
        ax = Axes3D(fig)
        #        ax = fig.gca(projection='3d')
        ax.set_xlabel(r'period-$t$')
        ax.set_ylabel(r'age-$s$')
        ax.set_zlabel(r'individual consumption $c_{s,t}$')
        strideval = max(int(1), int(round(S / 10)))
        ax.plot_surface(tmatc,
                        smatc,
                        cpath[:, :T - 1],
                        rstride=strideval,
                        cstride=strideval,
                        cmap=cmap_cp)
        output_path = os.path.join(output_dir, "cpath")
        plt.savefig(output_path)
        # plt.show()

    return tpi_output