diff --git a/Machine_Learning/gan.py b/Machine_Learning/gan.py new file mode 100644 index 00000000..82f32e01 --- /dev/null +++ b/Machine_Learning/gan.py @@ -0,0 +1,267 @@ +import tensorflow as tf +import random +import os +os.environ["CUDA_VISIBLE_DEVICES"]="1" +import cv2 +import numpy as np +import scipy.misc + +import matplotlib.pyplot as plt + + + +slim = tf.contrib.slim + +HEIGHT, WIDTH, CHANNEL = 64, 64, 3 #The size and channel of the image, this one is RGB with 64x64 [64,64,3] +BATCH_SIZE = 9 +EPOCH = 5000 +data = 'image' +new_path = './' + data + + +def lrelu(x, n, leak=0.2): + return tf.maximum(x, leak * x, name=n) + +def save_images(images, size, image_path): + return imsave(inverse_transform(images), size, image_path) + +def inverse_transform(images): + return (images+1.)/2. + +def merge(images, size): + h, w = images.shape[1], images.shape[2] + if (images.shape[3] in (3,4)): + c = images.shape[3] + img = np.zeros((h * size[0], w * size[1], c)) + for idx, image in enumerate(images): + i = idx % size[1] + j = idx // size[1] + img[j * h:j * h + h, i * w:i * w + w, :] = image + return img + elif images.shape[3]==1: + img = np.zeros((h * size[0], w * size[1])) + for idx, image in enumerate(images): + i = idx % size[1] + j = idx // size[1] + img[j * h:j * h + h, i * w:i * w + w] = image[:,:,0] + return img + else: + raise ValueError('in merge(images,size) images parameter ' + 'must have dimensions: HxW or HxWx3 or HxWx4') + +def imsave(images, size, path): + image = np.squeeze(merge(images, size)) + return scipy.misc.imsave(path, image) + + + +def process_data(): + cur_dir = os.getcwd() + file_dir = os.path.join(cur_dir,'data/image')#The folder where the images are + images=[] + for pic in os.listdir(file_dir): + images.append(os.path.join(file_dir,pic)) + dataset = tf.convert_to_tensor(images,dtype=tf.string)#Processing the image + images_queue = tf.train.slice_input_producer([dataset]) + data = tf.read_file(images_queue[0]) + image = tf.image.decode_jpeg(data,channels=CHANNEL) + image = tf.image.random_flip_left_right(image) + image = tf.image.random_brightness(image, max_delta=0.1) + image = tf.image.random_contrast(image, lower=0.9, upper=1.1) + size = [HEIGHT,WIDTH] + image = tf.image.resize_images(image, size) + image.set_shape([HEIGHT, WIDTH, CHANNEL]) + image = tf.cast(image, tf.float32) + image = image / 255.0 + + images_batch = tf.train.shuffle_batch( + [image], batch_size=BATCH_SIZE, + num_threads=4, capacity=200 + 3 * BATCH_SIZE, + min_after_dequeue=200) + num_images = len(images) + + return images_batch, num_images + + +def generator(input,input_dim,is_train,reuse=False):#The generator model + c1 ,c2, c3, c4, c5 = 512, 256, 128, 64, 32 # number of channels + output_dim = CHANNEL # RGB image + with tf.variable_scope('gen') as scope: + if reuse: + scope.reuse_variables() + w1 = tf.get_variable('weights1', shape=[input_dim, 4 * 4 * c1], dtype=tf.float32, + initializer=tf.truncated_normal_initializer(stddev=0.02)) + b1 = tf.get_variable('biases1',shape = [4*4*c1],dtype=tf.float32, + initializer=tf.constant_initializer(0.0)) + fc1 = tf.matmul(input,w1)+b1 + + conv_0 = tf.reshape(fc1, shape=[-1, 4, 4, c1], name='conv0') + batch_norm_0 = bn1 = tf.contrib.layers.batch_norm(conv_0, is_training=is_train, epsilon=1e-5, decay=0.9, + updates_collections=None, scope='bn0') + act_conv_0 = lrelu(batch_norm_0,"activation_conv_0") + conv_1 = tf.layers.conv2d_transpose(act_conv_0, c2, kernel_size=[5, 5], strides=[2, 2], padding="SAME", + kernel_initializer=tf.truncated_normal_initializer(stddev=0.02), + name='conv1') + batch_norm_1 = tf.contrib.layers.batch_norm(conv_1, is_training=is_train, epsilon=1e-5, decay=0.9, + updates_collections=None, scope='bn1') + act_conv_1 = lrelu(batch_norm_1,"activation_conv_1") + conv_2 = tf.layers.conv2d_transpose(act_conv_1,c3,kernel_size=[5,5],strides=[2,2],padding='SAME', + kernel_initializer=tf.truncated_normal_initializer(stddev=0.02), + name='conv2') + batch_norm_2 = tf.contrib.layers.batch_norm(conv_2, is_training=is_train, epsilon=1e-5, decay=0.9, + updates_collections=None, scope='bn2') + act_conv_2 = lrelu(batch_norm_2,"activation_conv_2") + conv_3 = tf.layers.conv2d_transpose(act_conv_2,c4,kernel_size=[5,5],strides=[2,2],padding='SAME', + kernel_initializer=tf.truncated_normal_initializer(stddev=0.02), + name='conv3') + batch_norm_3 = tf.contrib.layers.batch_norm(conv_3, is_training=is_train, epsilon=1e-5, decay=0.9, + updates_collections=None, scope='bn3') + act_conv_3 = lrelu(batch_norm_3,"activation_conv_3") + + conv_output = tf.layers.conv2d_transpose(act_conv_3,output_dim,kernel_size=[5,5],strides=[2,2],padding='SAME', + kernel_initializer=tf.truncated_normal_initializer(stddev=0.02), + name='conv_ouput') + output_act = lrelu(conv_output,"final_output") + return output_act + + +def discriminator(input,is_train,reuse=False):#The discriminator model + c1,c2,c3,c4 = 64, 128, 256, 512 + + with tf.variable_scope("discriminator") as scope: + if reuse: + scope.reuse_variables() + conv_1 = tf.layers.conv2d(input, c1, kernel_size=[5, 5], strides=[2, 2], padding="SAME", + kernel_initializer=tf.truncated_normal_initializer(stddev=0.02), + name='conv1') + batch_norm_1 = tf.contrib.layers.batch_norm(conv_1, is_training=is_train, epsilon=1e-5, decay=0.9, + updates_collections=None, scope='bn1') + act_conv_1 = lrelu(batch_norm_1, n='activation_conv_1') + conv_2 = tf.layers.conv2d(act_conv_1, c2, kernel_size=[5, 5], strides=[2, 2], padding="SAME", + kernel_initializer=tf.truncated_normal_initializer(stddev=0.02), + name='conv2') + batch_norm_2 = tf.contrib.layers.batch_norm(conv_2, is_training=is_train, epsilon=1e-5, decay=0.9, + updates_collections=None, scope='bn2') + act_conv_2 = lrelu(batch_norm_2, n='activation_conv_2') + conv_3 = tf.layers.conv2d(act_conv_2, c3, kernel_size=[5, 5], strides=[2, 2], padding="SAME", + kernel_initializer=tf.truncated_normal_initializer(stddev=0.02), + name='conv3') + batch_norm_3 = tf.contrib.layers.batch_norm(conv_3, is_training=is_train, epsilon=1e-5, decay=0.9, + updates_collections=None, scope='bn3') + act_conv_3 = lrelu(batch_norm_3, n='activation_conv_3') + + conv_4 = tf.layers.conv2d(act_conv_3, c4, kernel_size=[5, 5], strides=[2, 2], padding="SAME", + kernel_initializer=tf.truncated_normal_initializer(stddev=0.02), + name='conv4') + batch_norm_4 = tf.contrib.layers.batch_norm(conv_4, is_training=is_train, epsilon=1e-5, decay=0.9, + updates_collections=None, scope='bn4') + act_conv_4 = lrelu(batch_norm_4, n='activation_conv_4') + + dim = int(np.prod(act_conv_4.get_shape()[4:])) + + input_fc = tf.reshape(act_conv_4,shape=[-1,dim],name="input_fc") + + w1 = tf.get_variable('weights2', shape=[input_fc.shape[-1],1], dtype=tf.float32, + initializer=tf.truncated_normal_initializer(stddev=0.02)) + b1 = tf.get_variable('biases2',shape = [1],dtype=tf.float32, + initializer=tf.constant_initializer(0.0)) + fc1 = tf.matmul(input_fc,w1)+b1 + + output = tf.nn.sigmoid(fc1) + + return fc1 + + +def train(): + input_dim = 100 + real_image = tf.placeholder(tf.float32, shape=[None, HEIGHT, WIDTH, CHANNEL], name='real_image') + input_fake = tf.placeholder(tf.float32, shape=[None, input_dim], name='noise_image') + is_train = tf.placeholder(tf.bool, name='is_train') + + + fake_image = generator(input_fake,input_dim,is_train) + + real_result = discriminator(real_image, is_train) + fake_result = discriminator(fake_image, is_train, reuse=True) + + d_loss = tf.reduce_mean(fake_result)-tf.reduce_mean(real_result) + g_loss = -tf.reduce_mean(fake_result) + + t_vars = tf.trainable_variables() + d_vars = [var for var in t_vars if 'dis' in var.name] + g_vars = [var for var in t_vars if 'gen' in var.name] + trainer_d = tf.train.RMSPropOptimizer(learning_rate=2e-4).minimize(d_loss, var_list=d_vars) + trainer_g = tf.train.RMSPropOptimizer(learning_rate=2e-4).minimize(g_loss, var_list=g_vars) + + d_clip = [v.assign(tf.clip_by_value(v, -0.01, 0.01)) for v in d_vars] + + batch_size = BATCH_SIZE + image_batch, samples_num = process_data() + + batch_num = int(samples_num / batch_size) + total_batch = 0 + sess = tf.Session() + saver = tf.train.Saver() + sess.run(tf.global_variables_initializer()) + sess.run(tf.local_variables_initializer()) + save_path = saver.save(sess, "tmp/model.ckpt") + ckpt = tf.train.latest_checkpoint(data) + saver.restore(sess, save_path) + coord = tf.train.Coordinator() + threads = tf.train.start_queue_runners(sess=sess, coord=coord) + + print('total training sample num:%d' % samples_num) + print('batch size: %d, batch num per epoch: %d, epoch num: %d' % (batch_size, batch_num, EPOCH)) + print('start training...') + dLossArray = [] + iArray = [] + gLossArray = [] + + for i in range(0,EPOCH): + print(i) + for j in range(batch_num): + print(j) + disc_iterations=5 + gen_iterations=1 + train_noise = np.random.uniform(-1.0, 1.0, size=[batch_size, input_dim]).astype(np.float32) + train_noise = np.random.uniform(-1.0, 1.0, size=[batch_size, input_dim]).astype(np.float32) + for k in range(disc_iterations): + print(k) + train_image = sess.run(image_batch) + # wgan clip weights + sess.run(d_clip) + # Update the discriminator + _, dLoss = sess.run([trainer_d, d_loss], + feed_dict={input_fake: train_noise, real_image: train_image, is_train: True}) + for k in range(gen_iterations): + _, gLoss = sess.run([trainer_g, g_loss], + feed_dict={input_fake: train_noise, is_train: True}) + + if i % 30 == 0:#Each 30 epochs + if not os.path.exists('model/' + data): + os.makedirs('model/' + data) + saver.save(sess, 'model/' + data + '/' + str(i)) + if i % 10 == 0:#Each 10 epochs: + # save images + if not os.path.exists(new_path): + os.makedirs(new_path) + sample_noise = np.random.uniform(-1.0, 1.0, size=[batch_size, input_dim]).astype(np.float32) + imgtest = sess.run(fake_image, feed_dict={input_fake: sample_noise, is_train: False}) + # imgtest = imgtest * 255.0 + # imgtest.astype(np.uint8) + save_images(imgtest, [3, 3], 'data/imageval/' + str(i) + '.png') + print('train:[%d],d_loss:%f,g_loss:%f' % (i, dLoss, gLoss)) + dLossArray.append(dLoss) + gLossArray.append(gLoss) + iArray.append(i) + print(dLossArray, gLossArray, iArray) + plt.plot(dLossArray,'r-', gLossArray,'g-') + plt.ylabel('loss') + plt.xlabel('x10 epochs') + plt.savefig('plot'+ str(i)+'.png') + coord.request_stop() + coord.join(threads) + + +if __name__=='__main__': + train() diff --git a/Mathematical_Algorithms/src/prime_numbers.py b/Mathematical_Algorithms/src/prime_numbers.py new file mode 100644 index 00000000..78b87147 --- /dev/null +++ b/Mathematical_Algorithms/src/prime_numbers.py @@ -0,0 +1,20 @@ + + +print("Type a number") +n = input() +a = 2 +b = True #A boolean that tells us, if it is true so is a prime number, if not, is not a prime number + + +while a < int(n):#This will divide n to every natural number between 1 and n, a prime number wouldn't get a integer number + if int(n) % a == 0 : + print("n is not a prime number!") + a = int(n)#End this while + b = False + + a = a + 1 + + + +if b == True: + print("n is a prime number!")