def plot_data(self):
     for i,dat in enumerate(self.data):
         plt.imshow(dat, cmap=cm.jet, interpolation=None, extent=[11,22,-3,2])
         txt='plot '.format(self.n[i])
         txt+='\nmin {0:.2f} und max {1:.2f}'.format(self.min[i],self.max[i])
         txt+='\navg. min {0:.2f} und avg. max {1:.2f}'.format(mean(self.min),mean(self.max))
         plt.suptitle(txt,x=0.5,y=0.98,ha='center',va='top',fontsize=10)
         plt.savefig(join(self.plotpath,'pic_oo_'+str(self.n[i])+'.png'))
         plt.close()  # wichtig, sonst wird in den selben Plot immer mehr reingepackt
Example #2
0
    def update(dummy):

        if str(radio_buttons.value_selected) != labels.label:
            labels.label = radio_buttons.value_selected
            slider.valmax = len(labels[labels.label].samples)
            slider.val = labels[labels.label].index
            ax_slider.set_xlim(0, slider.valmax)

        labels[labels.label].index = int(slider.val)

        current = labels[labels.label].samples.iloc[labels[labels.label].index]
        with open(os.path.join(dirname, current['name']), 'rb') as f:
            patch = pickle.load(f)
            print(f.name)

        plt.suptitle(patch.name)

        vol = patch.volumetric[2:2 + 3].transpose(1, 2, 0)
        display_vol = 2 * np.arctan(vol) / np.pi

        radius = patch.rgb.shape[1] / 2
        extent = (-radius, radius, -radius, radius)

        ax1.clear()
        ax2.clear()
        ax3.clear()

        ax1.imshow(patch.rgb.transpose(1, 2, 0), extent=extent)
        ax1.set_title('rgb')

        ax2.imshow(patch.rgb.transpose(1, 2, 0), extent=extent)
        ax2.imshow(display_vol, extent=extent, alpha=0.5)
        if patch.obb is not None:
            patch.obb.plot(ax2, lw=4, color='yellow')
            patch.obb.plot(ax2, lw=3, ls='--', color='red')
        ax2.set_title('both')

        ax3.imshow(display_vol, extent=extent)
        ax3.set_title('vol:max={:.1f}'.format(vol.max()))

        fig.canvas.draw_idle()
def train(n_epochs, _batch_size, start_epoch=0):
    """
        train with fixed batch_size for given epochs
        make some example plots and save model after each epoch
    """
    global batch_size
    batch_size = _batch_size
    # create a dataqueue with the keras facilities. this allows
    # to prepare the data in parallel to the training
    sample_dataqueue = GeneratorEnqueuer(generate_real_samples(batch_size),
                                         use_multiprocessing=True)
    sample_dataqueue.start(workers=2, max_queue_size=10)
    sample_gen = sample_dataqueue.get()

    # targets for loss function
    gan_sample_dataqueue = GeneratorEnqueuer(
        generate_latent_points_as_generator(batch_size),
        use_multiprocessing=True)
    gan_sample_dataqueue.start(workers=2, max_queue_size=10)
    gan_sample_gen = gan_sample_dataqueue.get()

    # targets for loss function
    valid = -np.ones((batch_size, 1))
    fake = np.ones((batch_size, 1))
    dummy = np.zeros((batch_size, 1))  # Dummy gt for gradient penalty

    bat_per_epo = int(n_samples / batch_size)

    # we need to call the discriminator once in order
    # to initialize the input shapes
    [X_real, cond_real] = next(sample_gen)
    latent = np.random.normal(size=(batch_size, latent_dim))
    critic_model.predict([X_real, cond_real, latent])
    for i in trange(n_epochs):
        epoch = 1 + i + start_epoch
        # enumerate batches over the training set
        for j in trange(bat_per_epo):

            for _ in range(n_disc):
                # fetch a batch from the queue
                [X_real, cond_real] = next(sample_gen)
                latent = np.random.normal(size=(batch_size, latent_dim))
                d_loss = critic_model.train_on_batch(
                    [X_real, cond_real, latent], [valid, fake, dummy])
                # we get for losses back here. average, valid, fake, and gradient_penalty
                # we want the average of valid and fake
                d_loss = np.mean([d_loss[1], d_loss[2]])

            # train generator
            # prepare points in latent space as input for the generator
            [latent, cond] = next(gan_sample_gen)
            # update the generator via the discriminator's error
            g_loss = generator_model.train_on_batch([latent, cond], valid)
            # summarize loss on this batch
            print(f'{epoch}, {j + 1}/{bat_per_epo}, d_loss {d_loss}' + \
                  f' g:{g_loss} ')  # , d_fake:{d_loss_fake} d_real:{d_loss_real}')

            if np.isnan(g_loss) or np.isnan(d_loss):
                raise ValueError('encountered nan in g_loss and/or d_loss')

            hist['d_loss'].append(d_loss)
            hist['g_loss'].append(g_loss)

        # plot generated examples
        plt.figure(figsize=(25, 25))
        n_plot = 30
        X_fake, cond_fake = generate_fake_samples(n_plot)
        for iplot in range(n_plot):
            plt.subplot(n_plot, 25, iplot * 25 + 1)
            plt.imshow(cond_fake[iplot, :, :].squeeze(),
                       cmap=plt.cm.gist_earth_r,
                       norm=LogNorm(vmin=0.01, vmax=1))
            plt.axis('off')
            for jplot in range(1, 24):
                plt.subplot(n_plot, 25, iplot * 25 + jplot + 1)
                plt.imshow(X_fake[iplot, jplot, :, :].squeeze(),
                           vmin=0,
                           vmax=1,
                           cmap=plt.cm.hot_r)
                plt.axis('off')
        plt.colorbar()
        plt.suptitle(f'epoch {epoch:04d}')
        plt.savefig(
            f'{plotdir}/fake_samples_{params}_{epoch:04d}_{j:06d}.{plot_format}'
        )

        # plot loss
        plt.figure()
        plt.plot(hist['d_loss'], label='d_loss')
        plt.plot(hist['g_loss'], label='g_loss')
        plt.ylabel('batch')
        plt.legend()
        plt.savefig(f'{plotdir}/training_loss_{params}.{plot_format}')
        pd.DataFrame(hist).to_csv('hist.csv')
        plt.close('all')

        generator.save(f'{outdir}/gen_{params}_{epoch:04d}.h5')
        critic.save(f'{outdir}/disc_{params}_{epoch:04d}.h5')
Example #4
0
    plt.subplot(241).set_title("无翻拍 : %s 分" % score_1)
    plt.imshow(image_1)
    plt.axis('off')
    plt.subplot(242).set_title("翻拍 : %s 分" % score_2)
    plt.imshow(image_2)
    plt.axis('off')
    plt.subplot(243).set_title("无翻拍 : %s 分" % score_3)
    plt.imshow(image_3)
    plt.axis('off')
    plt.subplot(244).set_title("无翻拍-黑白 : %s 分" % score_4)
    plt.imshow(image_4)
    plt.axis('off')

    plt.subplot(245).set_title("电脑拍摄 : %s 分" % score_5)
    plt.imshow(image_5)
    plt.axis('off')
    plt.subplot(246).set_title("手机拍摄 : %s 分" % score_6)
    plt.imshow(image_6)
    plt.axis('off')
    plt.subplot(247).set_title("电脑拍摄-翻拍 : %s 分" % score_7)
    plt.imshow(image_7)
    plt.axis('off')
    plt.subplot(248).set_title("手机拍摄-翻拍 : %s 分" % score_8)
    plt.imshow(image_8)
    plt.axis('off')

    plt.subplots_adjust(left=0.1, right=0.9, top=0.9, bottom=0.1)
    plt.axis('off')
    plt.suptitle("腾讯-活体检测")
    plt.show()
Example #5
0
    def plot_feature_space(self,
                           m=0,
                           n=1,
                           c=None,
                           r=300,
                           hold=False,
                           xlim=None,
                           ylim=None,
                           xtpl='MNF %d',
                           ytpl='MNF %d',
                           alpha=0.5,
                           stitle='MNF Feature Space: Axes %d and %d',
                           interact=False):
        '''
        Create a 2D projection of the feature space and display it.
        '''
        self.__dims__ = (m, n, c)  # Remember these indices

        # Create a new figure of size 9x9 points, using 72 dots per inch
        fig = figure(figsize=self.size, dpi=self.dpi)
        self.ax = fig.add_subplot(111)
        defaults = {
            'linewidths': (0, ),
            's': (30, ),
            'cmap': 'YlGnBu',
            'alpha': alpha
        }

        if self.__raveled__:
            if c is not None:
                self.ax.scatter(self.rfeatures[:, m],
                                self.rfeatures[:, n],
                                c=self.rfeatures[:, c],
                                **defaults)

            else:
                self.ax.scatter(self.rfeatures[:, m], self.rfeatures[:, n],
                                **defaults)

        else:
            i = j = r  # Select square subsets
            if c is not None:
                # Plot the data; if a third dimension in color is requested...
                self.ax.scatter(self.rfeatures[0:i, 0:j, m],
                                self.rfeatures[0:i, 0:j, n],
                                c=self.rfeatures[0:i, 0:j, c],
                                **defaults)

            else:
                self.ax.scatter(self.rfeatures[0:i, 0:j, m],
                                self.rfeatures[0:i, 0:j, n], **defaults)

        if c is not None:
            plt.colorbar(orientation='vertical')
            t = '2D Projection with Axis %d in Color' % (c + 1)

        else:
            t = '2D Projection'

        # Allow users to change the x- and y-axis limits
        axes = plt.gca()
        if xlim is not None:
            axes.set_xlim(xlim)

        if ylim is not None:
            axes.set_ylim(ylim)

        plt.xlabel(xtpl % (m + 1), fontsize=14)
        plt.ylabel(ytpl % (n + 1), fontsize=14)
        plt.suptitle(stitle % (m + 1, n + 1), fontsize=18, fontweight='bold')
        plt.title(t, fontsize=16)

        if not hold:
            plt.show()

        if not hold and interact:
            self.on_reset()
            self.ax.figure.canvas.mpl_connect('button_press_event',
                                              self.on_press)
            return self.ax
Example #6
0
plt.rcParams['legend.labelspacing']=0.1
figsize=(7.5,3)

sub = df.query('n_ens==10')
plt.figure(figsize=(20,11))
plt.subplot(3, 2, 1)
# convert rmse to m2/a2
plt.plot(sub['leadtime'], sub['rmse_ensmean']*9.81, label='ensmean', color='black')
plt.plot(sub['leadtime'], sub['rmse_ctrl']*9.81, label='ctrl')
plt.plot(sub['leadtime'], sub['spread']*9.81, label='spread',color='black', linestyle='--')
plt.legend(loc='upper left', fontsize=14)
plt.ylabel('rmse (solid) \n spread (dashed) [$m^2/s^2$]')
plt.xlabel('leadtime [h]')
plt.xlabel('leadtime [h]')
sns.despine()
plt.suptitle(f'GEFS reforecasts')

plt.subplot(3, 2, 5)
plt.plot(sub['leadtime'], sub['crps']*9.81, color='black')
plt.ylabel('crps [$m^2/s^2$]')
plt.xlabel('leadtime [h]')
plt.xlabel('leadtime [h]')
sns.despine()

plt.subplot(3, 2, 3)
plt.plot(sub['leadtime'][1:], sub['corr'][1:], label='svd', color='black')

plt.xlabel('leadtime [h]')
plt.ylabel('spread-error correlation')
sns.despine()
plt.ylim((0, 0.9))
for i in range(0, len(init_dates), 20):
    init_date = init_dates[i]
    gefs = data.sel(time=init_date)
    svd = data_svd[i]
    rand = data_rand[i]
    netens = data_netens[i]

    svd = xr.DataArray(data=svd, coords=gefs.coords, dims=gefs.dims)
    rand = xr.DataArray(data=rand, coords=gefs.coords, dims=gefs.dims)
    netens = xr.DataArray(data=netens, coords=gefs.coords, dims=gefs.dims)

    plt.figure()
    plt.subplot(221)
    gefs.plot()
    plt.title('gefs')
    plt.subplot(222)
    svd.plot()
    plt.title('svd')
    plt.subplot(223)
    rand.plot()
    plt.title('rand')
    plt.subplot(224)
    netens.plot()
    plt.title('multitrain')
    plt.suptitle(init_date.strftime('%Y%m%d'))

    plt.tight_layout()

    plt.savefig(f'plots/ensmean_snapshots_{i:03d}.png', dpi=300)
    plt.savefig(f'plots/ensmean_snapshots_{i:03d}.pdf')
df = pd.concat(res_df)
df.to_csv(f'{plotdir}/gen_and_real_ameans_{params}_{epoch:04d}.csv')

# make boxplot
for showfliers in (True, False):

    plt.figure()
    plt.subplot(211)
    sns.boxplot('hour', 'precip', data=df, hue='typ', showfliers=showfliers)
    plt.xlabel('')
    sns.despine()
    plt.subplot(212)
    sns.boxplot('hour', 'fraction', data=df, hue='typ', showfliers=showfliers)
    sns.despine()
    plt.suptitle(f'n={n_sample}')
    plt.savefig(
        f'{plotdir}/daily_cycle_showfliers{showfliers}_{params}_{epoch:04d}.svg'
    )

## for a single real one, generate a large
# number of fake distributions, and then
# plot the areamean in a lineplot
# we generate 100 fake distributions with different noise accross the samples
# and additionally 10 fake ones that use the same noise for all plots
# the latter we plot in the same color (1 seperate color for each generated one)
# so that we can compare them accross the plots

n_to_generate = 20
n_fake_per_real = 100
n_fake_per_real_samenoise = 10
Example #9
0
        plt.figure()
        for i,xval in enumerate(x[0]):
            if i==0:
                rxmin, rxmax = xval-0.004, xval+0.004
            else:
                rxmin, rxmax = xval-0.03, xval+0.03
            rymin, rymax = np.min(y[:,i]), np.max(y[:,i])
            rect = plt.Rectangle((rxmin, rymin), rxmax-rxmin, rymax-rymin, facecolor='grey',alpha=0.4)
            plt.gca().add_patch(rect)
        for i,sc in enumerate(loaded):
            plt.plot(x[i],y[i])
        if nc != 8: plt.semilogy()
        #if nc in yldict: plt.ylim(yldict[nc])
        plt.xlabel('FES / maxFES')
        plt.ylabel(r'error = $f_i(x)-f_i(x^*)$')
        plt.suptitle(ttxt,x=0.5,y=0.98, ha='center',va='top', fontsize=10)
        plt.suptitle(date,x=0.97,y=0.02, ha='right',va='bottom', fontsize=8)
        plt.savefig(join(plotloc,'allruns_c'+str(nc).zfill(3)+'_'+eat+'_'+df[:-1]+'.png'))
        plt.close()

#        for i,xval in enumerate(x[0]):
#            if i==0:
#                rxmin, rxmax = xval-0.004, xval+0.004
#            else:
#                rxmin, rxmax = xval-0.03, xval+0.03
#            rymin, rymax = np.min(y[:,i]), np.max(y[:,i])
#            rect = plt.Rectangle((rxmin, rymin), rxmax-rxmin, rymax-rymin, facecolor='grey',alpha=0.4)
#            plt.gca().add_patch(rect)
#        plt.plot(x[0,:],np.min(y,axis=0),c='c')
#        plt.plot(x[0,:],np.max(y,axis=0),c='c')
#        if nc != 8: plt.semilogy()
Example #10
0
            else:
                rxmin, rxmax = xval - 0.03, xval + 0.03
            rymin, rymax = np.min(y[:, i]), np.max(y[:, i])
            rect = plt.Rectangle((rxmin, rymin),
                                 rxmax - rxmin,
                                 rymax - rymin,
                                 facecolor='grey',
                                 alpha=0.4)
            plt.gca().add_patch(rect)
        for i, sc in enumerate(loaded):
            plt.plot(x[i], y[i])
        if nc != 8: plt.semilogy()
        #if nc in yldict: plt.ylim(yldict[nc])
        plt.xlabel('FES / maxFES')
        plt.ylabel(r'error = $f_i(x)-f_i(x^*)$')
        plt.suptitle(ttxt, x=0.5, y=0.98, ha='center', va='top', fontsize=10)
        plt.suptitle(date, x=0.97, y=0.02, ha='right', va='bottom', fontsize=8)
        plt.savefig(
            join(
                plotloc, 'allruns_c' + str(nc).zfill(3) + '_' + eat + '_' +
                df[:-1] + '.png'))
        plt.close()

#        for i,xval in enumerate(x[0]):
#            if i==0:
#                rxmin, rxmax = xval-0.004, xval+0.004
#            else:
#                rxmin, rxmax = xval-0.03, xval+0.03
#            rymin, rymax = np.min(y[:,i]), np.max(y[:,i])
#            rect = plt.Rectangle((rxmin, rymin), rxmax-rxmin, rymax-rymin, facecolor='grey',alpha=0.4)
#            plt.gca().add_patch(rect)
Example #11
0
for i in range(h):
    yc = ylim[1] - i * dy
    for j in range(m):
        xc = xlim[0] + j * dx
        dat[j * n] = xc
        dat[j * n + 1] = yc
    #print "first DNA: ",dat[0],dat[1];
    #print "2nd DNA: ",dat[2],dat[3];
    #print "last DNA: ",dat[2*m-2],dat[2*m-1];
    r1 = tf.test_func(dat, f, ct.c_int(n), ct.c_int(m), ct.c_int(k))
    rarr[i, :] = [f[j] for j in range(m)]

plt.pcolor(x, y, flipud(rarr), vmin=np.min(rarr), vmax=np.max(rarr))
plt.colorbar()
plt.xlim(xlim)
plt.ylim(ylim)
plt.xlabel(r'$x_1$')
plt.ylabel(r'$x_2$')
plt.title('CEC-2013 test function suite:\nno. {0}: {1}'.format(k, fnames[k]))
plt.suptitle('evaluated using ctypes',
             x=0.02,
             y=0.02,
             ha='left',
             va='bottom',
             fontsize=9)
#plt.show()
plt.savefig('./pics/test_func_' + str(k).zfill(2) +
            '_using_ctypes_zoomlevel_2.png')
plt.clf()
plt.close('all')
Example #12
0
# initially the k-loop was here, and it didn't work for any plot except the first one
# for k in range(1,29):  # so, this didn't work
print 'now function ',k
for i in range(h):
    yc=ylim[1]-i*dy
    for j in range(m):
        xc=xlim[0]+j*dx;
        dat[j*n]=xc;
        dat[j*n+1]=yc;
    #print "first DNA: ",dat[0],dat[1];
    #print "2nd DNA: ",dat[2],dat[3];
    #print "last DNA: ",dat[2*m-2],dat[2*m-1];
    r1=tf.test_func(dat,f,ct.c_int(n),ct.c_int(m),ct.c_int(k))
    rarr[i,:]=[f[j] for j in range(m)]



plt.pcolor(x,y,flipud(rarr),vmin=np.min(rarr),vmax=np.max(rarr))
plt.colorbar()
plt.xlim(xlim)
plt.ylim(ylim)
plt.xlabel(r'$x_1$')
plt.ylabel(r'$x_2$')
plt.title('CEC-2013 test function suite:\nno. {0}: {1}'.format(k,fnames[k]))
plt.suptitle('evaluated using ctypes',x=0.02,y=0.02,ha='left',va='bottom',fontsize=9)
#plt.show()
plt.savefig('./pics/test_func_'+str(k).zfill(2)+'_using_ctypes_zoomlevel_2.png')
plt.clf()
plt.close('all')