def fit(self, x, y, iterations=1, shuffle=True):
data = as_matrix(x)
response = y
self.layers[0] = nn.layer(len(data[0]), bias=self.layers[0].bias)
# initialize the hidden layers with stacked autoencoders
if self.pretrain:
out = x
for index in range(1, len(self.layers) - 1):
layer = self.layers[index]
trained = autoencoder(len(layer.visible))
trained.fit(out)
out = trained.predict(out)
layer.weights = trained.layers[1].weights
errors = []
for iteration in range(iterations):
if shuffle:
inds = numpy.random.permutation(range(len(data)))
data = data[inds]
response = response[inds]
for row_ind, row in enumerate(data):
# propagate forward
self.propagate_forward(row)
# propagate backward -- the input weights never change
layer = self.layers[-1]
target = response[row_ind]
errors.append(sum(target - layer.visible))
# do hidden layers
for layer_index in range(len(self.layers) - 1, 0, -1):
layer = self.layers[layer_index]
input_layer = self.layers[layer_index - 1]
target = layer.propagate_backward(input_layer, target)
return errors
def __autoencoder_mnist__():
X_train, y_train, X_val, y_val, X_test, y_test = load_mnist()
X_train = X_train.reshape(X_train.shape[0], -1)
X_val = X_val.reshape(X_val.shape[0], -1)
X_test = X_test.reshape(X_test.shape[0], -1)
print 'Train data shape: ', X_train.shape
print 'Train labels shape: ', y_train.shape
print 'Test data shape: ', X_test.shape
print 'Test labels shape: ', y_test.shape
print ''
ninput = 28*28
nhidden = 100
net = autoencoder(layer_units=(ninput, nhidden, ninput), bias=False, act_func = 'sigmoid',
loss_type='euclidean', seed=12)
tic = time.time()
stats = net.train_with_SGD(X_train, learning_rate=0.1, learning_rate_decay=0.95, reg=0.001,
num_iters=2000, batchsize=128, mu=0.9)
toc = time.time()
print toc-tic, 'sec elapsed'
print 'overall loss: ', net.loss(X_train, reg=0.01, opt='test')
plot_net_output(net, stats, X_train)
units = [784,10]
action = ['softplus']
l_rate = 0.01
grad = "gradient"
f = open("../datasets/train-images.idx3-ubyte","r")
arr = np.fromfile(f, '>u1', 60000 * 28 * 28).reshape((60000, 784))
max_value = 0xFF
arr = arr.astype(float)
arr -= max_value / 2.0
arr /= max_value
data = arr
print data.shape
auto = autoencoder(units,action)
auto.generate_encoder()
auto.generate_decoder()
auto.train(data,n_iters=1000,batch=None,display=False,noise=False,gradient=grad,learning_rate=l_rate)
def train_ae(self):
ae = autoencoder(self.myVanHat)
return ae
import numpy as np
from autoencoder import autoencoder
data = np.random.rand(100,20).astype("float32")
auto = autoencoder([20,15,10],['sigmoid','sigmoid'])
auto.generate_encoder(euris=True)
auto.generate_decoder(symmetric=False)
auto.pre_train(data)
auto.train(data,n_iters=20,record_weight=True,reg_weight=False,learning_rate=20.0,reg_lambda=1.0,batch=None,display=False,noise=False)
numTrain = round(len(labeledSet) / 2)
trainSet = labeledSet[1:numTrain]
testSet = labeledSet[numTrain + 1 :]
trainData = train_set[0][trainSet, :]
trainLabels = train_set[1][trainSet]
testData = train_set[0][testSet, :]
testLabels = train_set[1][testSet]
# unlabeled
unlabeledSet = np.where(train_set[1] >= 5)[0]
unlabeledData = train_set[0][unlabeledSet, :]
############# train
iterations = 200
model = autoencoder(input_layer_size, hidden_layer_size, beta, rho, lambd)
input_data = unlabeledData.T
theta = scipy.optimize.minimize(
model.autoencoder_Cost_Grad,
x0=model.theta,
args=(input_data,),
method="L-BFGS-B",
jac=True,
options={"maxiter": iterations},
)
W1 = theta.x[0 : model.W1_dim].reshape(hidden_layer_size, input_layer_size)
b1 = theta.x[model.W1_dim + model.W2_dim : model.W1_dim + model.W2_dim + model.b1_dim].reshape(hidden_layer_size, 1)
showHiddenIMAGES(W1, patch_size, hidden_patch_size)
data = data+abs(np.min(data))
data = data/np.max(data)
data = data.astype("float32")
int_dim = 100
bat = batch.seq_batch(data,1000)
#units = [data.shape[1],int(math.ceil(data.shape[1]*1.2))+5,int(max(math.ceil(data.shape[1]/4),int_dim+2)+3),
# int(max(math.ceil(data.shape[1]/10),int_dim+1)),int_dim]
units = [5600,2300,1100,600,200,100]
act = ['sigmoid','sigmoid','sigmoid','sigmoid','sigmoid']
#act = ['relu','relu','relu','relu']
auto = autoencoder.autoencoder(units,act)
auto.generate_encoder()
auto.generate_decoder()
auto.pre_train(data,n_iters=5000)
session = auto.init_network()
ic,bc = auto.train(data,batch=bat,le=False,tau=1.0,session=session,n_iters=2000,display=False,noise=False,noise_level=0.015)
print 'Init: ',ic,' Best:',bc
mid = auto.get_hidden(data,session=session)
out = auto.get_output(data,session=session)
import numpy from autoencoder import autoencoder from encoder import encoder if __name__ == "__main__": ### autoencoder parameter iteration = 100 learning = 0.005 x_length = 1000 y_length = 100 prob = 0.0 filepath = 'lr.txt' w_path = 'lr/h1_1000to100_w.txt' bias_path = 'lr/h1_1000to100_eb.txt' readpath1 = 'lr.txt' readpath2 = 'lt.txt' ### stacked denoising autoencoder print 'sda start' ob1 = autoencoder(iteration, learning, x_length, y_length, filepath, prob) ob1.sda() ob1.encfile(readpath1) ob1.encfile(readpath2) print 'autoencoder finish' """ print 'encode start' ob2 = encoder(w_path, bias_path) ob2.encfile(readpath1) ob2.encfile(readpath2) print 'finish' """
from autoencoder import autoencoder
import tensorflow
import numpy as np
auto = autoencoder([3,5,2],['softplus','softplus'])
auto.generate_encoder(euris=True)
auto.generate_decoder(symmetric=False)
data = np.random.rand(20,3).astype("float32");
s = auto.init_network()
print s.run(auto.layers[1].W)
par = auto.pre_train_rbm(data,learning_rate=0.0001)
print par[2]
print auto.session.run(auto.layers[1].W)
hidden_layer_size_1 = 200 # 200 # hidden layer 1 Size
hidden_layer_size_2 = 200 #200 # hidden layer 2 Size
rho = 0.1 # desired average activation of the hidden units.
beta = 3 # weight of sparsity penalty term
####### load data
f = gzip.open('/Users/wanyanxie/Summer_2014_Study/Deep_Learning/mnist.pkl.gz', 'rb')
train_set, valid_set, test_set = cPickle.load(f)
f.close()
####debug
#train_set= (train_set[0][1:50],train_set[1][1:50])
####### Train the first sparse autoencoder
iterations = 200
model_1=autoencoder(input_layer_size, hidden_layer_size_1, beta, rho, lambd)
theta_1= scipy.optimize.minimize(model_1.autoencoder_Cost_Grad, x0=model_1.theta,
args = (train_set[0].T,),
method = 'L-BFGS-B',
jac = True,
options = {'maxiter': iterations})
W1_1 = theta_1.x[0:model_1.W1_dim].reshape(hidden_layer_size_1,input_layer_size)
b1_1 = theta_1.x[model_1.W1_dim+model_1.W2_dim: model_1.W1_dim+model_1.W2_dim +model_1.b1_dim].reshape(hidden_layer_size_1,1)
####### Train the second sparse autoencoder
iterations = 200
feedForward_train_1 = feedForwardAutoencoder(W1_1,b1_1, train_set[0].T)
a2_train = feedForward_train_1.hidden_layer_activiation()
model_2=autoencoder(hidden_layer_size_1, hidden_layer_size_2, beta, rho, lambd)
#plt.imshow(Temp,interpolation='nearest')
#plt.show()
#################################################################################
##### n effet on a 4 carre par image, si forte ressemblance critere texte on merge les 4 images de chacun pour le test on prend param de lènsemble + proche
# Pour chaque carre on retient le future high level au niveau local 4 carre et 48 feauture ie de dimension 4*3*4*4 = 192
Sample_Feature_train = np.zeros((X_train.shape[0],size_Feature_Autocodeur))
Sample_Feature_val = np.zeros((X_val.shape[0],size_Feature_Autocodeur))
type_LvsG =2 ## Local
for Rang_Image in range(Size_train):
if (Rang_Image % 50 == 0):
print('Feature Creation for image :',Rang_Image)
Index_Image =Rang_Image
#X_Sub_Image = V_X_Carre_train[:,0:Index_Image+1,:,:,:]
#Y_Sub_Image = V_Y_Carre_train[:,0:Index_Image+1,:,:,:]
Auto_encoder_local = autoencoder(size_input_Local,Size_Encode_L,Size_Epoch,BATCH_SIZE_Enc,V_X_Carre_train[:,Index_Image,:,:,:],V_Y_Carre_train[:,Index_Image,:,:,:],type_LvsG,size_Feature_Kernel)
Auto_encoder_local.build_network(X_d,X_g)
Auto_encoder_local.learn(V_X_Carre_train[:,Index_Image,:,:,:],V_Y_Carre_train[:,Index_Image,:,:,:])
V_encode = Auto_encoder_local.encode((V_X_Carre_train[:,Index_Image,:,:,:]).astype('float32'))
V_encode = np.reshape(V_encode,size_Feature_Autocodeur)
#V_encode += 1
#V_encode *= (255/2)
#V_encode = np.uint8(V_encode)
# on laisse la valeur entre -1 et 1
Sample_Feature_train[Index_Image,:] = V_encode
for Rang_Image in range(Size_val):
if (Rang_Image % 50 == 0):
print('Feature Creation for image :',Rang_Image)
Index_Image =Rang_Image
#X_Sub_Image = V_X_Carre_train[:,0:Index_Image+1,:,:,:]
