Beispiel #1
0
def pbc_sep(p1, p2):

    arrow = sep(p1, p2)
    rem = np.mod(arrow, 18)  # The image in the first cube
    mic_separation_vector = np.mod(rem+18/2, 18)-18/2

    return np.array(mic_separation_vector)
Beispiel #2
0
    def updatePlot(self, time, data):
        '''
            Adds data to the plot.
            time is a list,
            data is a list of lists, each list corresponding to a line on the plot
        '''
        if self.init == True:  # Initialize the plot the first time routine is called
            for i in range(len(data)):
                # Instantiate line object and add it to the axes
                self.line.append(
                    Line2D(time,
                           data[i],
                           color=self.colors[np.mod(i,
                                                    len(self.colors) - 1)],
                           ls=self.line_styles[np.mod(
                               i,
                               len(self.line_styles) - 1)],
                           label=self.legend if self.legend != None else None))
                self.ax.add_line(self.line[i])
            self.init = False
            # add legend if one is specified
            if self.legend != None:
                plt.legend(handles=self.line)
        else:  # Add new data to the plot
            # Updates the x and y data of each line.
            for i in range(len(self.line)):
                self.line[i].set_xdata(time)
                self.line[i].set_ydata(data[i])

        # Adjusts the axis to fit all of the data
        self.ax.relim()
        self.ax.autoscale()
Beispiel #3
0
 def animate(k):
     # clear panels
     ax.cla()
     ax2.cla()
     
     # print rendering update
     if np.mod(k+1,25) == 0:
         print ('rendering animation frame ' + str(k+1) + ' of ' + str(num_frames))
     if k == num_frames - 1:
         print ('animation rendering complete!')
         time.sleep(1.5)
         clear_output()
     
     ####### plot total model on original dataset #######      
     ax.scatter(self.x_train,self.y_train,color = 'k',s = 60,edgecolor = self.colors[1] ,linewidth = 1.5)
 
     ax.scatter(self.x_valid,self.y_valid,color = 'k',s = 60,edgecolor = self.colors[0] ,linewidth = 1.5)
         
     # plot fit
     if k > 0:
         # plot current fit
         a = inds[k-1] 
         steps = runner.best_steps[:a+1]
         self.draw_fit(ax,steps,a)
             
         # plot train / valid errors up to this point
         self.plot_train_valid_errors(ax2,k-1,train_errors,valid_errors,inds)
         
     # make panel size
     ax.set_xlim([xmin,xmax])
     ax.set_ylim([ymin,ymax])
     return artist,
        def animate(k):
            # clear panels
            ax.cla()
            ax1.cla()

            # print rendering update
            if np.mod(k + 1, 25) == 0:
                print('rendering animation frame ' + str(k + 1) + ' of ' +
                      str(num_frames))
            if k == num_frames - 1:
                print('animation rendering complete!')
                time.sleep(1.5)
                clear_output()

            # get current run for cost function history plot
            a = inds[k]
            run = runs[a]

            # pluck out current weights
            self.draw_fit_trainval(ax, runs, a)

            # show cost function history
            if show_history == True:
                ax1.cla()
                self.plot_train_valid_errors(ax1, k, train_errors,
                                             valid_errors, labels)

            return artist,
Beispiel #5
0
        def animate(k):
            # clear panels
            ax1.cla()
            ax2.cla()
            ax3.cla()
            ax4.cla()
            
            # print rendering update
            if np.mod(k+1,25) == 0:
                print ('rendering animation frame ' + str(k+1) + ' of ' + str(num_frames))
            if k == num_frames - 1:
                print ('animation rendering complete!')
                time.sleep(1.5)
                clear_output()
            
            #### plot training, testing, and full data ####            
            # pluck out current weights 
            a = inds[k]
            steps = runner.best_steps[:a+1]
            
            # produce static img
            self.draw_boundary(ax1,steps,a)
            self.static_N2_simple(ax1,train_valid = 'original')
            self.draw_boundary(ax2,steps,a)

            self.static_N2_simple(ax2,train_valid = 'train')
            self.draw_boundary(ax3,steps,a)
            self.static_N2_simple(ax3,train_valid = 'validate')

            #### plot training / validation errors ####
            self.plot_train_valid_errors(ax4,a,train_errors,valid_errors,inds)
            return artist,
Beispiel #6
0
        def animate(k):
            # clear current plots for next frame of animation
            ax1.cla()
            ax2.cla()

            # print rendering update
            if np.mod(k + 1, 25) == 0:
                print('rendering animation frame ' + str(k + 1) + ' of ' +
                      str(num_frames))
            if k == len(lam_range) - 1:
                print('animation rendering complete!')
                time.sleep(1.5)
                clear_output()

            # choose current regularization parameter
            self.lam = lam_range[k]

            # run gradient descent with two user-chosen initial values and chosen regularization value
            w_hist_1 = self.gradient_descent(w=w_init_1,
                                             alpha=alpha,
                                             max_its=max_its)
            w_hist_2 = self.gradient_descent(w=w_init_2,
                                             alpha=alpha,
                                             max_its=max_its)

            # plot data points in panel 1, and cost function in panel 2
            self.show_data_and_fit(ax1, w_hist_1[-1], color='lime')
            self.show_data_and_fit(ax1, w_hist_2[-1], color='magenta')

            # plot logistic surface, as well as gradient descent paths, in panel 2
            self.plot_logistic_surface(ax2)
            self.show_descent_path(ax2, w_hist_1, color='lime')
            self.show_descent_path(ax2, w_hist_2, color='magenta')

            return artist,
        def animate(t):
            # clear panels for next slide
            ax1.cla()
            ax2.cla()
            ax3.cla()
            
            # print rendering update
            if np.mod(t+1,25) == 0:
                print ('rendering animation frame ' + str(t+1) + ' of ' + str(num_frames))
            if t == num_frames - 1:
                print ('animation rendering complete!')
                time.sleep(1.5)
                clear_output()
              
            # plot function 1
            ax1.plot_surface(w1_vals,w2_vals,g1_vals,alpha = 0.1,color = 'w',rstride=10, cstride=10,linewidth=2,edgecolor = 'k') 
            ax1.set_title("$g_1$",fontsize = 15)
            ax1.view_init(view[0],view[1])
            ax1.axis(set_axis)

            # plot function 2
            ax2.plot_surface(w1_vals,w2_vals,g2_vals,alpha = 0.1,color = 'w',rstride=10, cstride=10,linewidth=2,edgecolor = 'k') 
            ax2.set_title("$g_2$",fontsize = 15)
            ax2.view_init(view[0],view[1])
            ax2.axis(set_axis)
            
            # plot combination of both
            alpha = alpha_vals[t]
            g_combo = alpha*g1_vals + (1 - alpha)*g2_vals
            ax3.plot_surface(w1_vals,w2_vals,g_combo,alpha = 0.1,color = 'k',rstride=10, cstride=10,linewidth=2,edgecolor = 'k')             
            ax3.set_title('$\\alpha\,g_1 + (1 - \\alpha)\,g_2$',fontsize = 15)
            ax3.view_init(view[0],view[1])
            ax3.axis(set_axis)
            
            return artist,
Beispiel #8
0
        def animate(k):
            # clear panels
            ax1.cla()
            
            # current color
            color = self.colorspec[k]

            # print rendering update
            if np.mod(k+1,25) == 0:
                print ('rendering animation frame ' + str(k+1) + ' of ' + str(num_frames))
            if k == num_frames - 1:
                print ('animation rendering complete!')
                time.sleep(1.5)
                clear_output()
            
            ###### make left panel - plot data and fit ######
            # initialize fit
            w = self.w_hist[k]
            y_fit = w[0] + x_fit*w[1]
            
            # scatter data
            self.scatter_pts(ax1)
            
            # plot fit to data
            ax1.plot(x_fit,y_fit,color = color,linewidth = 3) 

            return artist,
 def animate(k):
     ax.cla()
     
     # print rendering update
     if np.mod(k+1,25) == 0:
         print ('rendering animation frame ' + str(k+1) + ' of ' + str(num_slides))
     if k == num_slides - 1:
         print ('animation rendering complete!')
         time.sleep(1.5)
         clear_output()
     
     # define beta
     special_size = size_range[k]
     special_weight = weight_range[k]
     beta = np.ones((1,self.y.size))
     beta[:,ind1] = special_weight
     
     # run optimizer
     w_hist,g_hist = bits.newtons_method(g,w,self.x,self.y,beta,max_its)
     w_best = w_hist[-1]
     self.model = lambda data: bits.model(data,w_best)
     
     # scatter plot all data
     self.plot_data(ax,special_class,special_size)
     
     # draw decision boundary
     self.draw_decision_boundary(ax)
     return artist,
 def animate(k):
     # clear panels
     ax.cla()
     ax1.cla()
     
     # print rendering update
     if np.mod(k+1,25) == 0:
         print ('rendering animation frame ' + str(k+1) + ' of ' + str(num_frames))
     if k == num_frames - 1:
         print ('animation rendering complete!')
         time.sleep(1.5)
         clear_output()
     
     # get current run for cost function history plot
     a = inds[k]
     run = runs[a]
     
     # pluck out current weights 
     self.draw_fit(ax,ax1,runs,a)
     
     # show cost function history
     if show_history == True:
         ax1.cla()
         ax1.scatter(current_ind,cost_history[current_ind],s = 60,color = 'r',edgecolor = 'k',zorder = 3)
         self.plot_cost_history(ax1,cost_history,start)
         
     return artist,
Beispiel #11
0
        def animate(k):
            # clear panels
            ax.cla()
            ax1.cla()
            ax2.cla()
            ax3.cla()

            # print rendering update
            if np.mod(k + 1, 25) == 0:
                print('rendering animation frame ' + str(k + 1) + ' of ' +
                      str(num_frames))
            if k == num_frames - 1:
                print('animation rendering complete!')
                time.sleep(1.5)
                clear_output()

            #### plot training, testing, and full data ####
            # pluck out current weights
            w_best = weight_history[k]

            # produce static img
            self.static_N2_simple(ax, w_best, run, train_valid='original')
            self.draw_boundary(ax, run, w_best, train_valid='train')

            self.static_N2_simple(ax1, w_best, run, train_valid='train')
            self.draw_boundary(ax1, run, w_best, train_valid='train')
            self.static_N2_simple(ax2, w_best, run, train_valid='validate')
            self.draw_boundary(ax2, run, w_best, train_valid='validate')

            #### plot training / validation errors ####
            self.plot_train_valid_errors(ax3, k, train_errors, valid_errors,
                                         num_units)
            return artist,
        def animate(k):
            # clear panels
            ax1.cla()
            
            # current color
            color = self.colorspec[k]

            # print rendering update
            if np.mod(k+1,25) == 0:
                print ('rendering animation frame ' + str(k+1) + ' of ' + str(num_frames))
            if k == num_frames - 1:
                print ('animation rendering complete!')
                time.sleep(1.5)
                clear_output()
            
            ###### make left panel - plot data and fit ######
            # initialize fit
            w = self.w_hist[k]
            y_fit = self.sigmoid(w[0] + x_fit*w[1])
            
            # scatter data
            self.scatter_pts(ax1)
            
            # plot fit to data
            ax1.plot(x_fit,y_fit,color = color,linewidth = 2) 

            ###### make right panel - plot contour and steps ######
            if k == 0:
                ax2.scatter(w[0],w[1],s = 90,facecolor = color,edgecolor = 'k',linewidth = 0.5, zorder = 3)
            if k > 0 and k < num_frames:
                self.plot_pts_on_contour(ax2,k,color)
            if k == num_frames -1:
                ax2.scatter(w[0],w[1],s = 90,facecolor = color,edgecolor = 'k',linewidth = 0.5, zorder = 3)
               
            return artist,
Beispiel #13
0
        def animate(k):
            # clear panels
            ax1.cla()
            ax2.cla()

            # print rendering update
            if np.mod(k + 1, 25) == 0:
                print('rendering animation frame ' + str(k + 1) + ' of ' +
                      str(num_frames))
            if k == num_frames - 1:
                print('animation rendering complete!')
                time.sleep(1.5)
                clear_output()

            # scatter original data
            ax1.scatter(self.x.flatten(),
                        self.y.flatten(),
                        color='k',
                        s=40,
                        edgecolor='w',
                        linewidth=0.9)

            if k > 0:
                # get current run for cost function history plot
                a = inds[k - 1]
                run = runs[a]

                # pluck out current weights
                self.draw_fit(ax1, run, a)

                # cost function history plot
                self.cost_history_plot(ax2, cost_evals, a)

            return artist,
Beispiel #14
0
        def animate(k):
            # clear panels
            ax.cla()

            # print rendering update
            if np.mod(k + 1, 25) == 0:
                print('rendering animation frame ' + str(k + 1) + ' of ' +
                      str(num_frames))
            if k == num_frames - 1:
                print('animation rendering complete!')
                time.sleep(1.5)
                clear_output()

            # scatter original data
            ax.scatter(self.x.flatten(),
                       self.y.flatten(),
                       color='k',
                       s=40,
                       edgecolor='w',
                       linewidth=0.9)

            if k > 0:
                # get current run for cost function history plot
                a = inds[k - 1]
                model = run.models[a]
                steps = run.best_steps[:a + 1]

                # pluck out current weights
                self.draw_boosting_fit(ax, steps, a)

            return artist,
Beispiel #15
0
def angle_diff(theta1, theta2):
    ''' An angle subtraction method.
    '''
    if isinstance(theta1, tf.Tensor) or isinstance(theta2, tf.Tensor):
        delta = tf.mod(theta1 - theta2 - pi, 2 * pi) - pi
    else:
        delta = np.mod(theta1 - theta2 - pi, 2 * pi) - pi
    return delta
        def animate(k):
            # clear panels
            ax.cla()
            lam = lams[k]

            # print rendering update
            if np.mod(k + 1, 25) == 0:
                print('rendering animation frame ' + str(k + 1) + ' of ' +
                      str(num_frames))
            if k == num_frames - 1:
                print('animation rendering complete!')
                time.sleep(1.5)
                clear_output()

            # run optimization
            if algo == 'gradient_descent':
                weight_history, cost_history = self.gradient_descent(
                    g, w, self.x, self.y, lam, alpha_choice, max_its,
                    batch_size)
            if algo == 'RMSprop':
                weight_history, cost_history = self.RMSprop(
                    g, w, self.x, self.y, lam, alpha_choice, max_its,
                    batch_size)

            # choose set of weights to plot based on lowest cost val
            ind = np.argmin(cost_history)

            # classification? then base on accuracy
            if 'counter' in kwargs:
                # create counting cost history as well
                counts = [
                    counter(v, self.x, self.y, lam) for v in weight_history
                ]
                if k == 0:
                    ind = np.argmin(counts)
                count = counts[ind]
                acc = 1 - count / self.y.size
                acc = np.round(acc, 2)

            # save lowest misclass weights
            w_best = weight_history[ind][1:]

            # plot
            ax.axhline(c='k', zorder=2)

            # make bar plot
            ax.bar(np.arange(0, len(w_best)), w_best, color='k', alpha=0.5)

            # dress panel
            title1 = r'$\lambda = ' + str(np.round(lam, 2)) + '$'
            costval = cost_history[ind][0]
            title2 = ', cost val = ' + str(np.round(costval, 2))
            if 'counter' in kwargs:
                title2 = ', accuracy = ' + str(acc)
            title = title1 + title2
            ax.set_title(title)
            ax.set_xlabel('learned weights')
            return artist,
Beispiel #17
0
        def animate(k):
            # clear panels
            ax1.cla()
            
            # set axis in left panel
            self.move_axis_left(ax1)
            
            # current color
            color = self.colorspec[k]

            # print rendering update
            if np.mod(k+1,25) == 0:
                print ('rendering animation frame ' + str(k+1) + ' of ' + str(num_frames))
            if k == num_frames - 1:
                print ('animation rendering complete!')
                time.sleep(1.5)
                clear_output()
            
            ###### make left panel - plot data and fit ######
            # initialize fit
            w = self.w_hist[k]
                    
            # reshape and plot the surface, as well as where the zero-plane is        
            y_fit = w[0] + w[1]*x1_vals + w[2]*x2_vals

            # plot cost surface
            ax1.plot_surface(x1_vals,x2_vals,y_fit,alpha = 0.1,color = color,rstride=25, cstride=25,linewidth=0.25,edgecolor = 'k',zorder = 2)  
            
            # scatter data
            self.scatter_pts(ax1)
            #ax1.view_init(view[0],view[1])
            
            # plot connector between points for visualization purposes
            if k == 0:
                w_new = self.w_hist[k]
                g_new = self.least_squares(w_new)[0]
                ax2.scatter(k,g_new,s = 0.1,color = 'w',linewidth = 2.5,alpha = 0,zorder = 1)      # plot approx
                
            if k > 0:
                w_old = self.w_hist[k-1]
                w_new = self.w_hist[k]
                g_old = self.least_squares(w_old)[0]
                g_new = self.least_squares(w_new)[0]
     
                ax2.plot([k-1,k],[g_old,g_new],color = color,linewidth = 2.5,alpha = 1,zorder = 2)      # plot approx
                ax2.plot([k-1,k],[g_old,g_new],color = 'k',linewidth = 3.5,alpha = 1,zorder = 1)      # plot approx
            
            # set viewing limits for second panel
            ax2.axhline(y=0, color='k',zorder = 0,linewidth = 0.5)
            ax2.set_xlabel('iteration',fontsize = 12)
            ax2.set_ylabel(r'$g(\mathbf{w})$',fontsize = 12,rotation = 0,labelpad = 25)
            ax2.set_xlim([-0.5,len(self.w_hist)])
            
            # set axis in left panel
            self.move_axis_left(ax1)
                
            return artist,
Beispiel #18
0
        def animate(k):
            # clear panels
            ax1.cla()
            ax2.cla()
            ax3.cla()

            # print rendering update
            if np.mod(k+1,25) == 0:
                print ('rendering animation frame ' + str(k+1) + ' of ' + str(num_frames))
            if k == num_frames - 1:
                print ('animation rendering complete!')
                time.sleep(1.5)
                clear_output()
            
            # scatter data
            ind0 = np.argwhere(self.y == +1)
            ind0 = [e[1] for e in ind0]
            ind1 = np.argwhere(self.y == -1)
            ind1 = [e[1] for e in ind1]
            for ax in [ax1,ax2,ax3]:
                ax.scatter(self.x[0,ind0],self.x[1,ind0],s = pt_size, color = self.colors[0], edgecolor = 'k',antialiased=True)
                ax.scatter(self.x[0,ind1],self.x[1,ind1],s = pt_size, color = self.colors[1], edgecolor = 'k',antialiased=True)
                
            if k == 0:
                ax1.set_title(str(0) + ' units fit to data',fontsize = 14,color = 'w')
                ax1.set_title(str(0) + ' units fit to data',fontsize = 14,color = 'w')
                ax1.set_title(str(0) + ' units fit to data',fontsize = 14,color = 'w')
                
                ax1.set_xlim([xmin1,xmax1])
                ax1.set_ylim([xmin2,xmax2])
                ax2.set_xlim([xmin1,xmax1])
                ax2.set_ylim([xmin2,xmax2])                
                ax3.set_xlim([xmin1,xmax1])
                ax3.set_ylim([xmin2,xmax2])
                
            # plot fit
            if k > 0:
                # get current run
                a1 = inds1[k-1] 
                a2 = inds2[k-1] 
                a3 = inds3[k-1] 

                run1 = runs1[a1]
                a1 = len(run1.w_init) - 1

                run2 = runs2[a2]
                model3 = runs3.models[a3]
                steps = runs3.best_steps[:a3+1]
                
                # plot models to data
                self.draw_fit(ax1,run1,a1)
                self.draw_fit(ax2,run2,a2 + 1)
                self.draw_boosting_fit(ax3,steps,a3)
                
            return artist,
Beispiel #19
0
        def animate(k):
            # clear panels
            ax1.cla()

            # print rendering update
            if np.mod(k + 1, 25) == 0:
                print('rendering animation frame ' + str(k + 1) + ' of ' +
                      str(num_frames))
            if k == num_frames - 1:
                print('animation rendering complete!')
                time.sleep(1.5)
                clear_output()

            # plot x
            ax1.plot(np.arange(1, x.size + 1),
                     x,
                     alpha=1,
                     c='k',
                     linewidth=1,
                     zorder=2)

            # plot moving average - initial conditions
            if k == 1:
                ax1.plot(np.arange(1, T + 1),
                         y[:T],
                         alpha=0.75,
                         c='fuchsia',
                         linewidth=3,
                         zorder=3)

                # make vertical visual guides
                ax1.axvline(x=1)
                ax1.axvline(x=T)

            # plot moving average - everything after and including initial conditions
            if k > 1:
                j = k - 1
                # plot
                ax1.plot(np.arange(1, T + j + 1),
                         y[:T + j],
                         alpha=0.7,
                         c='fuchsia',
                         linewidth=3,
                         zorder=3)

                # make vertical visual guides
                ax1.axvline(x=j)
                ax1.axvline(x=j + T - 1)

            # label axes
            ax1.set_xlim([xmin, xmax])
            ax1.set_ylim([ymin, ymax])
            return artist,
Beispiel #20
0
def advect(f, vx, vy):
    """Instead of moving the cell centers forward in time using the velocity fields,
  we look for the particles which end up exactly at the cell centers by tracing
  backwards in time from the cell centers. See 'implicit Euler integration.'"""
    rows, cols = f.shape
    cell_xs, cell_ys = np.meshgrid(np.arange(cols), np.arange(rows))
    center_xs = (cell_xs - vx).ravel()  # look backwards one timestep
    center_ys = (cell_ys - vy).ravel()

    left_ix = np.floor(center_ys).astype(int)  # get locations of source cells.
    top_ix = np.floor(center_xs).astype(int)
    rw = center_ys - left_ix  # relative weight of cells on the right
    bw = center_xs - top_ix  # same for cells on the bottom
    left_ix = np.mod(left_ix, rows)  # wrap around edges of simulation.
    right_ix = np.mod(left_ix + 1, rows)
    top_ix = np.mod(top_ix, cols)
    bot_ix = np.mod(top_ix + 1, cols)

    # a linearly-weighted sum of the 4 cells closest to the source of the cell center.
    flat_f = (1 - rw) * ((1 - bw)*f[left_ix,  top_ix] + bw*f[left_ix,  bot_ix]) \
                  + rw * ((1 - bw)*f[right_ix, top_ix] + bw*f[right_ix, bot_ix])
    return np.reshape(flat_f, (rows, cols))
Beispiel #21
0
def advect(f, vx, vy):
    """Move field f according to x and y velocities (u and v)
       using an implicit Euler integrator."""
    rows, cols = f.shape
    cell_ys, cell_xs = np.meshgrid(np.arange(rows), np.arange(cols))
    center_xs = (cell_xs - vx).ravel()
    center_ys = (cell_ys - vy).ravel()

    # Compute indices of source cells.
    left_ix = np.floor(center_xs).astype(np.int)
    top_ix  = np.floor(center_ys).astype(np.int)
    rw = center_xs - left_ix              # Relative weight of right-hand cells.
    bw = center_ys - top_ix               # Relative weight of bottom cells.
    left_ix  = np.mod(left_ix,     rows)  # Wrap around edges of simulation.
    right_ix = np.mod(left_ix + 1, rows)
    top_ix   = np.mod(top_ix,      cols)
    bot_ix   = np.mod(top_ix  + 1, cols)

    # A linearly-weighted sum of the 4 surrounding cells.
    flat_f = (1 - rw) * ((1 - bw)*f[left_ix,  top_ix] + bw*f[left_ix,  bot_ix]) \
                 + rw * ((1 - bw)*f[right_ix, top_ix] + bw*f[right_ix, bot_ix])
    return np.reshape(flat_f, (rows, cols))
Beispiel #22
0
def advect(f, vx, vy):
    """Move field f according to x and y velocities (u and v)
       using an implicit Euler integrator."""
    rows, cols = f.shape
    cell_ys, cell_xs = np.meshgrid(np.arange(rows), np.arange(cols))
    center_xs = (cell_xs - vx).ravel()
    center_ys = (cell_ys - vy).ravel()

    # Compute indices of source cells.
    left_ix = np.floor(center_xs).astype(np.int)
    top_ix = np.floor(center_ys).astype(np.int)
    rw = center_xs - left_ix  # Relative weight of right-hand cells.
    bw = center_ys - top_ix  # Relative weight of bottom cells.
    left_ix = np.mod(left_ix, rows)  # Wrap around edges of simulation.
    right_ix = np.mod(left_ix + 1, rows)
    top_ix = np.mod(top_ix, cols)
    bot_ix = np.mod(top_ix + 1, cols)

    # A linearly-weighted sum of the 4 surrounding cells.
    flat_f = (1 - rw) * ((1 - bw)*f[left_ix,  top_ix] + bw*f[left_ix,  bot_ix]) \
                 + rw * ((1 - bw)*f[right_ix, top_ix] + bw*f[right_ix, bot_ix])
    return np.reshape(flat_f, (rows, cols))
Beispiel #23
0
    def _sim_step(self, a):
        pos = self._qsoc.snd_rcv(a)

        # Transform the relative cart position to [-0.4, +0.4]
        if self._calibrated:
            pos[0] = (pos[0] - self._norm_x_lim[0]
                      ) - 1. / 2. * (self._norm_x_lim[1] - self._norm_x_lim[0])

        x_dot = self._vel_filt_x(pos[0:1])
        th_dot = self._vel_filt_th(pos[1:2])

        # Normalize the angle from 0. to 2.*pi
        pos[1] = np.mod(pos[1], 2. * np.pi) - np.pi
        return np.concatenate([pos, x_dot, th_dot])
Beispiel #24
0
        def animate(k):
            # clear panels
            ax.cla()

            # print rendering update
            if np.mod(k + 1, 25) == 0:
                print('rendering animation frame ' + str(k + 1) + ' of ' +
                      str(num_frames))
            if k == num_frames - 1:
                print('animation rendering complete!')
                time.sleep(1.5)
                clear_output()

            #### scatter data ####
            # plot points in 2d and 3d
            ind0 = np.argwhere(self.y == +1)
            ind0 = [e[1] for e in ind0]
            ax.scatter(self.x[0, ind0],
                       self.x[1, ind0],
                       s=55,
                       color=self.colors[0],
                       edgecolor='k')

            ind1 = np.argwhere(self.y == -1)
            ind1 = [e[1] for e in ind1]
            ax.scatter(self.x[0, ind1],
                       self.x[1, ind1],
                       s=55,
                       color=self.colors[1],
                       edgecolor='k')

            # plot boundary
            if k > 0:
                # get current run for cost function history plot
                a = inds[k - 1]
                model = run.models[a]
                steps = run.best_steps[:a + 1]

                # pluck out current weights
                self.draw_boosting_fit(ax, steps, a)

            # cleanup panel
            ax.set_yticklabels([])
            ax.set_xticklabels([])
            ax.set_xticks([])
            ax.set_yticks([])
            ax.set_xlabel(r'$x_1$', fontsize=15)
            ax.set_ylabel(r'$x_2$', fontsize=15, rotation=0, labelpad=20)

            return artist,
 def animate(k):
     # clear panels
     ax1.cla()
     ax2.cla()
     
     # print rendering update
     if np.mod(k+1,25) == 0:
         print ('rendering animation frame ' + str(k+1) + ' of ' + str(num_frames))
     if k == num_frames - 1:
         print ('animation rendering complete!')
         time.sleep(1.5)
         clear_output()
     
     #### scatter data ####
     # plot points in 2d and 3d
     ind0 = np.argwhere(self.y == +1)
     ind0 = [e[1] for e in ind0]
     ax1.scatter(self.x[0,ind0],self.x[1,ind0],s = 55, color = self.colors[0], edgecolor = 'k')
                 
     ind1 = np.argwhere(self.y == -1)
     ind1 = [e[1] for e in ind1]
     ax1.scatter(self.x[0,ind1],self.x[1,ind1],s = 55, color = self.colors[1], edgecolor = 'k')
     
     # plot boundary
     if k > 0:
         # get current run for cost function history plot
         a = inds[k-1]
         run = runs[a]
         
         # pluck out current weights 
         self.draw_fit(ax1,run,a)
         
         # cost function value
         ax2.plot(np.arange(1,num_elements + 1),cost_evals,color = 'k',linewidth = 2.5,zorder = 1)
         ax2.scatter(a + 1,cost_evals[a],color = self.colors[0],s = 70,edgecolor = 'w',linewidth = 1.5,zorder = 3)
     
     # cleanup panels
     ax1.set_yticklabels([])
     ax1.set_xticklabels([])
     ax1.set_xticks([])
     ax1.set_yticks([])
     ax1.set_xlabel(r'$x_1$',fontsize = 15)
     ax1.set_ylabel(r'$x_2$',fontsize = 15,rotation = 0,labelpad = 20)  
     
     ax2.set_xlabel('number of units',fontsize = 12)
     ax2.set_title('cost function plot',fontsize = 14)
     ax2.set_xlim([minxc,maxxc])
     ax2.set_ylim([ymin,ymax])
 
     return artist,
Beispiel #26
0
def gradient_descent(g, w_unflat, alpha_choice, max_its, version, **kwargs):
    verbose = False
    if 'verbose' in kwargs:
        verbose = kwargs['verbose']

    # flatten the input function, create gradient based on flat function
    g_flat, unflatten, w = flatten_func(g, w_unflat)
    grad = compute_grad(g)

    # record history
    w_hist = []
    w_hist.append(w_unflat)

    # over the line
    for k in range(max_its):
        if verbose == True:
            if np.mod(k, 5) == 0:
                print('started iteration ' + str(k) + ' of ' + str(max_its))

        # check if diminishing steplength rule used
        if alpha_choice == 'diminishing':
            alpha = 1 / float(k)
        else:
            alpha = alpha_choice

        # plug in value into func and derivative
        grad_eval = grad(w_unflat)
        grad_eval, _ = flatten(grad_eval)

        ### normalized or unnormalized descent step? ###
        if version == 'normalized':
            grad_norm = np.linalg.norm(grad_eval)
            if grad_norm == 0:
                grad_norm += 10**-6 * np.sign(2 * np.random.rand(1) - 1)
            grad_eval /= grad_norm

        # take descent step
        w = w - alpha * grad_eval

        # record weight update
        w_unflat = unflatten(w)
        w_hist.append(w_unflat)

    if verbose == True:
        print('finished all ' + str(max_its) + ' iterations')

    return w_hist
Beispiel #27
0
        def animate(k):
            # clear panels for next slide
            ax1.cla()
            ax2.cla()
            ax3.cla()

            # print rendering update
            if np.mod(k + 1, 25) == 0:
                print('rendering animation frame ' + str(k + 1) + ' of ' +
                      str(num_frames))
            if k == num_frames - 1:
                print('animation rendering complete!')
                time.sleep(1.5)
                clear_output()

            # plot function 1
            ax1.plot(w_plot, g1_plot, color='k', zorder=1)
            ax1.set_title(title1, fontsize=15)

            # plot function 2
            ax2.plot(w_plot, g2_plot, color='k', zorder=1)
            ax2.set_title(title2, fontsize=15)

            # plot combination of both
            alpha = alpha_vals[k]

            if mode == 'regularization':
                g_combo = g1_plot + alpha * g2_plot
            else:
                g_combo = (1 - alpha) * g1_plot + alpha * g2_plot

            ax3.plot(w_plot, g_combo, color='k', zorder=1)
            ax3.set_title(title3, fontsize=15)

            # set vertical limits
            ax1.set_ylim([g1_min, g1_max])
            ax2.set_ylim([g2_min, g2_max])

            # set vertical limit markers
            gmin = np.amin(g_combo)
            gmax = np.amax(g_combo)
            g_gap = 0.2 * (gmax - gmin)
            gmin = gmin - g_gap
            gmax = gmax + g_gap
            ax3.set_ylim([gmin, gmax])

            return artist,
Beispiel #28
0
        def animate(k):
            # clear the panel
            ax.cla()

            # print rendering update
            if np.mod(k + 1, 5) == 0:
                print('rendering animation frame ' + str(k + 1) + ' of ' +
                      str(self.num_elements))
            if k == self.num_elements - 1:
                print('animation rendering complete!')
                time.sleep(1)
                clear_output()

            ####### plot a stump ######
            # pick a stump
            w = np.zeros((self.num_elements, 1))
            w[k] = 1

            # produce learned predictor
            s = np.linspace(xmin, xmax, 400)
            t = [self.tree_predict(np.asarray([v]), w) for v in s]

            # plot approximation and data in panel
            ax.scatter(self.x, self.y, c='k', edgecolor='w', s=50, zorder=2)
            ax.plot(s, t, linewidth=2.5, color=self.colors[0], zorder=3)

            # plot horizontal axis and dashed line to split point
            ax.axhline(c='k', linewidth=1, zorder=0)
            mid = (self.levels[k][0] + self.levels[k][1]) / float(2)
            o = np.linspace(0, ymax, 100)
            e = np.ones((100, 1))
            sp = self.splits[k]
            ax.plot(sp * e,
                    o,
                    linewidth=1.5,
                    color=self.colors[1],
                    linestyle='--',
                    zorder=1)

            # cleanup panel
            ax.set_xlim([xmin, xmax])
            ax.set_ylim([ymin, ymax])
            ax.set_xlabel(r'$x$', fontsize=14, labelpad=10)
            ax.set_ylabel(r'$y$', rotation=0, fontsize=14, labelpad=10)
            ax.set_xticks(np.arange(round(xmin), round(xmax) + 1, 1.0))
            ax.set_yticks(np.arange(round(ymin), round(ymax) + 1, 1.0))
Beispiel #29
0
        def animate(k):
            # clear panels
            ax1.cla()

            # print rendering update
            if np.mod(k + 1, 25) == 0:
                print('rendering animation frame ' + str(k + 1) + ' of ' +
                      str(num_frames))
            if k == num_frames - 1:
                print('animation rendering complete!')
                time.sleep(1.5)
                clear_output()

            # plot x
            ax1.plot(np.arange(1, x.size + 1),
                     x,
                     alpha=1,
                     c='k',
                     linewidth=1,
                     zorder=2)

            # plot running average - everything after and including initial conditions
            if k >= 1:
                j = k - 1
                # plot
                a = np.arange(1, j + 2)
                b = y[:j + 1]
                #print (a.shape,b.shape)
                ax1.plot(np.arange(1, j + 2),
                         y[:j + 1],
                         alpha=0.7,
                         c='fuchsia',
                         linewidth=3,
                         zorder=3)
                ax1.scatter(1,
                            y[0],
                            alpha=0.7,
                            c='fuchsia',
                            linewidth=3,
                            zorder=3)

            # label axes
            ax1.set_xlim([xmin, xmax])
            ax1.set_ylim([ymin, ymax])
            return artist,
Beispiel #30
0
        def animate(k):
            # clear panels
            ax1.cla()

            # print rendering update
            if np.mod(k + 1, 25) == 0:
                print('rendering animation frame ' + str(k + 1) + ' of ' +
                      str(num_frames))
            if k == num_frames - 1:
                print('animation rendering complete!')
                time.sleep(1.5)
                clear_output()

            # plot x
            ax1.plot(np.arange(1, x.size + 1),
                     x,
                     alpha=1,
                     c='k',
                     linewidth=1,
                     zorder=2)

            # create y
            if k == 0:
                alpha = params[0]
                y = func(x, alpha)
                #ax1.plot(np.arange(1,y.size + 1),y,alpha = 1,c = 'fuchsia',linewidth = 3,zorder = 3);
                ax1.set_title(r'Original data')

            if k > 0:
                alpha = params[k - 1]
                y = func(x, alpha)
                ax1.plot(np.arange(1, y.size + 1),
                         y,
                         alpha=0.9,
                         c='fuchsia',
                         linewidth=3,
                         zorder=3)
                ax1.set_title(r'$\alpha = $ ' + str(np.round(alpha, 2)))

            # label axes
            ax1.set_xlabel(r'$t$', fontsize=13)
            ax1.set_xlim([xmin, xmax])
            ax1.set_ylim([ymin, ymax])
            return artist,
    def animate(k):
        # clear the panels
        ax1.cla()
        ax2.cla()

        # print rendering update
        if np.mod(k + 1, 25) == 0:
            print('rendering animation frame ' + str(k + 1) + ' of ' +
                  str(num_frames))
        if k == num_frames - 1:
            print('animation rendering complete!')
            time.sleep(1.5)
            clear_output()

        if k > 0:
            # pull current tracer
            tracer = tracer_range[k - 1]
            tracer = np.array([float(tracer[0]), float(tracer[1])])
            tracer.shape = (2, 1)
            g_tracer = func(tracer)

        ### draw 3d version ###
        for ax in [ax1, ax2]:
            # plot function
            plot_func(func, view, ax)

            if k > 0:
                # scatter anchor point
                ax.scatter(anchor[0],
                           anchor[1],
                           g_anchor,
                           s=50,
                           c='lime',
                           edgecolor='k',
                           linewidth=1)
                # plot hyperplane connecting the anchor to tracer
                secant(func, anchor, tracer, ax)

                # reset tracer
                tracer = np.flipud(tracer)

        return artist,
Beispiel #32
0
def test_mod_arg1():
    fun = lambda x, y : np.mod(x, y)
    d_fun = grad(fun, 1)
    check_grads(fun, npr.rand(), npr.rand())
    check_grads(d_fun, npr.rand(), npr.rand())
Beispiel #33
0
def test_mod_arg1():
    fun = lambda x, y : np.mod(x, y)
    check_grads(fun)(npr.rand(), npr.rand())