In [1]:
import GAN.models as models
import GAN.toy_datasets as toys
import GAN.plotting as plotting
In [2]:
reload(toys)
# z,_ = toys.two_peaks(100000,split=False)
x,z = toys.three_peaks(500000,split=False)
In [3]:
c0 = np.random.uniform(-1,1,x.shape)+np.random.normal(0,0.1,x.shape)
# c0 = toys.two_peaks_target(x.shape[0])
def shift_cube(X):
c,x = X
val = (2.*c**3 - c**2)
return val + x
#return x + c
# return x + c + c**2
def shift_square(X):
c,x = X
val = (c + c**2)
return val + x
c0x = np.hstack([c0.reshape(-1,1),x.reshape(-1,1)])
c0z = np.hstack([c0.reshape(-1,1),x.reshape(-1,1)])
print(c0x.shape)
x_transform = np.apply_along_axis( shift_cube, 1, c0x ).reshape(x.shape)
#z_transform = np.apply_along_axis( shift, 1, c0z ).reshape(x.shape)
c_transform = c0 # + np.random.normal(0,0.1,c0.shape).reshape(x.shape)
x_transform -= x_transform.mean()
x_transform /= x_transform.std()
c_transform -= c_transform.mean()
c_transform /= c_transform.std()
# x_train, x_test, c_train, c_test, z_train, z_test = toys.train_test_split( x_transform, c_transform, z )
x_train = x_transform
z_train = z
c_train = c_transform
probs_test = [0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80,85,90,95]
c_quantiles = np.percentile(c_transform.ravel(),probs_test)
probs_test = probs_test[1:]
c_test = np.vstack( [c_quantiles[1:]]*len(probs_test) ).T.reshape(-1,1,1)
z_ravel = z.ravel()
z_test = np.vstack( [ np.percentile(z_ravel,probs_test) ]*len(probs_test) ).reshape(-1,1,1)
c_ravel = c_transform.ravel()
x_ravel = x_transform.ravel()
x_test = []
for iqt in range(c_quantiles.shape[0]-1):
q0 = c_quantiles[iqt]
q1 = c_quantiles[iqt+1]
x_slice = x_ravel[(c_ravel>q0) & (c_ravel<=q1)]
x_test.append( np.percentile(x_slice,probs_test) )
x_test = np.vstack( x_test ).reshape(-1,1,1)
In [4]:
plt.hexbin( c_transform.ravel(), x_transform.ravel() )
plt.show()
plotting.plot_hists(x_transform.ravel(),z.ravel())#,range=[-4,10])
In [5]:
plt.scatter( c_test.ravel(), x_test.ravel() )
plt.show()
plt.scatter( c_test.ravel(), z_test.ravel() )
plt.show()
In [6]:
p = 0
c_test[p,0],x_test[p,0]-z_test[p,0]
Out[6]:
In [7]:
reload(models)
gan = models.MyFFGAN( (1,1), (1,1), c_shape=(1,1),
g_opts=dict(name="G_32x3_64x3_128x3",kernel_sizes=[128]*3+[64]*3+[32]*3,#kernel_sizes=[128]*11,
# do_nl_activ=[False,"tanh"]*3+[False],
# do_poly=True,
# do_nl_activ="relu",do_skip=False, do_bn=True
),
d_opts=dict(name="D_512x5_tanh",kernel_sizes=[512]*5),
# dm_opts=dict(optimizer=models.Adam,opt_kwargs=dict(lr=1e-5)),
# am_opts=dict(optimizer=models.Adam,opt_kwargs=dict(lr=1e-5)),
dm_opts=dict(optimizer=models.RMSprop,opt_kwargs=dict(lr=0.0001, decay=6e-6)),
am_opts=dict(optimizer=models.RMSprop,opt_kwargs=dict(lr=0.0001, decay=6e-6)),
)
In [8]:
gan.get_generator()
Out[8]:
In [9]:
gan.get_discriminator()
Out[9]:
In [10]:
gan.compile()
Out[10]:
In [11]:
gan.get_generator().summary()
In [12]:
gan.get_discriminator().summary()
In [13]:
gan.am.summary()
In [14]:
gan.dm.summary()
In [ ]:
In [15]:
# import GAN.toy_datasets as toys
In [16]:
# reload(toys)
# x_train,x_test,z_train,z_test = toys.two_peaks(100000)
In [17]:
plotting.plot_hists(x_train.ravel(),z_train.ravel())
In [18]:
# reload(toys)
# x,z = toys.three_peaks(100000)
# plotting.plot_hists(x.ravel(),z.ravel())
In [19]:
probs = np.arange(1,100,1)
cdf_x = np.percentile(x_train,probs)
cdf_z = np.percentile(z_train,probs)
do = dict(x_train=x_train,z_train=z_train,c_x_train=c_train,
x_test=x_test,z_test=z_test,c_x_test=c_test,
n_disc_steps=1,n_gen_steps=1,
n_epochs=20,solution=(cdf_x,cdf_z),plot_every=1,batch_size=4096)
gan.fit(**do)
do.update(dict(n_disc_steps=2))
gan.fit(**do)
do.update(dict(n_disc_steps=3))
gan.fit(**do)
do.update(dict(n_disc_steps=5))
gan.fit(**do)
In [20]:
# c0 = np.random.uniform(-1,1,x.shape)+np.random.normal(0,0.1,x.shape)
# c0 -= c0.mean()
# c0 /= c0.std()
z = toys.white_source(x.shape[0])
# z,_ = toys.two_peaks(x.shape[0],split=False)
g_train = gan.get_generator().predict( [c_train,z] )[1]
# g_test = gan.get_generator().predict( [c_test,z_test] )[1]
# g_test_unique = np.unique(g_test)
# z_test_unique = np.unique(z_test)
# g_test.sort()
# z_test_unique.sort()
In [21]:
# g_quantiles = np.percentile(g,probs_test)
# x_quantiles = np.percentile(x_train,probs_test)
In [22]:
# plt.scatter(z_test_unique,g_quantiles-z_test_unique)
# plt.scatter(z_test_unique,g_test_unique-z_test_unique)
# plt.scatter(z_test_unique,x_quantiles-z_test_unique,color='red')
In [23]:
# plt.scatter(z_test,g_test-z_test)
# plt.scatter(z_test,x_test-z_test,color='red')
In [24]:
# g_quantiles - g_test
In [25]:
target = np.hstack( [c_train.reshape(-1,1), x_train.reshape(-1,1)] )
generated = np.hstack( [c_train.reshape(-1,1), g_train.reshape(-1,1)] )
In [26]:
plt.hexbin( c_train.ravel(), x_train.ravel() )
plt.show()
plt.hexbin( c_train.ravel(), g_train.ravel() )
plt.show()
In [27]:
probs2 = [0,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80,85,90,95,100]
c_quantiles = np.percentile(np.vstack([generated[:,0],target[:,0]]),probs2)
print(c_quantiles)
In [28]:
plotting.plot_hists(target[:,1],generated[:,1])
plt.show()
for iqt in range(c_quantiles.shape[0]-1):
q0 = c_quantiles[iqt]
q1 = c_quantiles[iqt+1]
target_slice = target[:,1][(target[:,0]>q0) & (target[:,0]<=q1)]
generated_slice = generated[:,1][(generated[:,0]>q0) & (generated[:,0]<=q1)]
print(q0, q1, target_slice.sum(), generated_slice.sum() )
#target_q = np.percentile( [ target_slice ] , probs2 )
#generated_q = np.percentile( [ generated_slice ], probs2 )
#plt.plot(target_q,generated_q-target_q,label='%d' % probs2[iqt+1])
plotting.plot_hists(target_slice,generated_slice)
plt.show()
#plt.legend()
#plt.show()
In [39]:
gan.am.output
Out[39]:
In [ ]: