diff --git a/gzy/tesorflow/AlexNET.py b/gzy/tesorflow/AlexNET.py
new file mode 100755
index 0000000..9513c1d
--- /dev/null
+++ b/gzy/tesorflow/AlexNET.py
@@ -0,0 +1,127 @@
+# -*- coding=UTF-8 -*-  
+import sys  
+import os  
+import random  
+import cv2  
+import math  
+import time  
+import numpy as np  
+import tensorflow as tf  
+import linecache  
+import string  
+import skimage  
+import imageio  
+# 输入数据  
+import input_data  
+mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)  
+# 定义网络超参数  
+learning_rate = 0.001  
+training_iters = 200000  
+batch_size = 64  
+display_step = 20  
+# 定义网络参数  
+n_input = 784  # 输入的维度  
+n_classes = 10 # 标签的维度  
+dropout = 0.8  # Dropout 的概率  
+# 占位符输入  
+x = tf.placeholder(tf.types.float32, [None, n_input])  
+y = tf.placeholder(tf.types.float32, [None, n_classes])  
+keep_prob = tf.placeholder(tf.types.float32)  
+# 卷积操作  
+def conv2d(name, l_input, w, b):  
+    return tf.nn.relu(tf.nn.bias_add( \  
+    tf.nn.conv2d(l_input, w, strides=[1, 1, 1, 1], padding='SAME'),b) \  
+    , name=name)  
+# 最大下采样操作  
+def max_pool(name, l_input, k):  
+    return tf.nn.max_pool(l_input, ksize=[1, k, k, 1], \  
+    strides=[1, k, k, 1], padding='SAME', name=name)  
+# 归一化操作  
+def norm(name, l_input, lsize=4):  
+    return tf.nn.lrn(l_input, lsize, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name=name)  
+# 定义整个网络   
+def alex_net(_X, _weights, _biases, _dropout):  
+    _X = tf.reshape(_X, shape=[-1, 28, 28, 1]) # 向量转为矩阵  
+    # 卷积层  
+    conv1 = conv2d('conv1', _X, _weights['wc1'], _biases['bc1'])  
+    # 下采样层  
+    pool1 = max_pool('pool1', conv1, k=2)  
+    # 归一化层  
+    norm1 = norm('norm1', pool1, lsize=4)  
+    # Dropout  
+    norm1 = tf.nn.dropout(norm1, _dropout)  
+   
+    # 卷积  
+    conv2 = conv2d('conv2', norm1, _weights['wc2'], _biases['bc2'])  
+    # 下采样  
+    pool2 = max_pool('pool2', conv2, k=2)  
+    # 归一化  
+    norm2 = norm('norm2', pool2, lsize=4)  
+    # Dropout  
+    norm2 = tf.nn.dropout(norm2, _dropout)  
+   
+    # 卷积  
+    conv3 = conv2d('conv3', norm2, _weights['wc3'], _biases['bc3'])  
+    # 下采样  
+    pool3 = max_pool('pool3', conv3, k=2)  
+    # 归一化  
+    norm3 = norm('norm3', pool3, lsize=4)  
+    # Dropout  
+    norm3 = tf.nn.dropout(norm3, _dropout)  
+   
+    # 全连接层，先把特征图转为向量  
+    dense1 = tf.reshape(norm3, [-1, _weights['wd1'].get_shape().as_list()[0]])   
+    dense1 = tf.nn.relu(tf.matmul(dense1, _weights['wd1']) + _biases['bd1'], name='fc1')   
+    # 全连接层  
+    dense2 = tf.nn.relu(tf.matmul(dense1, _weights['wd2']) + _biases['bd2'], name='fc2') 
+    # Relu activation  
+    # 网络输出层  
+    out = tf.matmul(dense2, _weights['out']) + _biases['out']  
+    return out  
+   
+# 存储所有的网络参数  
+weights = {  
+    'wc1': tf.Variable(tf.random_normal([3, 3, 1, 64])),  
+    'wc2': tf.Variable(tf.random_normal([3, 3, 64, 128])),  
+    'wc3': tf.Variable(tf.random_normal([3, 3, 128, 256])),  
+    'wd1': tf.Variable(tf.random_normal([4*4*256, 1024])),  
+    'wd2': tf.Variable(tf.random_normal([1024, 1024])),  
+    'out': tf.Variable(tf.random_normal([1024, 10]))  
+}  
+biases = {  
+    'bc1': tf.Variable(tf.random_normal([64])),  
+    'bc2': tf.Variable(tf.random_normal([128])),  
+    'bc3': tf.Variable(tf.random_normal([256])),  
+    'bd1': tf.Variable(tf.random_normal([1024])),  
+    'bd2': tf.Variable(tf.random_normal([1024])),  
+    'out': tf.Variable(tf.random_normal([n_classes]))  
+}  
+# 构建模型  
+pred = alex_net(x, weights, biases, keep_prob)  
+# 定义损失函数和学习步骤  
+cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, y))  
+optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)  
+# 测试网络  
+correct_pred = tf.equal(tf.argmax(pred,1), tf.argmax(y,1))  
+accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))  
+# 初始化所有的共享变量  
+init = tf.initialize_all_variables()  
+# 开启一个训练  
+with tf.Session() as sess:  
+    sess.run(init)  
+    step = 1  
+    # Keep training until reach max iterations  
+    while step * batch_size < training_iters:  
+        batch_xs, batch_ys = mnist.train.next_batch(batch_size)  
+        # 获取批数据  
+        sess.run(optimizer, feed_dict={x: batch_xs, y: batch_ys, keep_prob: dropout})  
+        if step % display_step == 0:  
+            # 计算精度  
+            acc = sess.run(accuracy, feed_dict={x: batch_xs, y: batch_ys, keep_prob: 1.})  
+            # 计算损失值  
+            loss = sess.run(cost, feed_dict={x: batch_xs, y: batch_ys, keep_prob: 1.})  
+            print "Iter " + str(step*batch_size) + ", Minibatch Loss= " + "{:.6f}".format(loss) + ", Training Accuracy= " + "{:.5f}".format(acc)  
+        step += 1  
+    print "Optimization Finished!"  
+    # 计算测试精度  
+    print "Testing Accuracy:", sess.run(accuracy, feed_dict={x: mnist.test.images[:256], y: mnist.test.labels[:256], keep_prob: 1.})  
\ No newline at end of file
diff --git a/gzy/tesorflow/KMP用于网页内容匹配.py b/gzy/tesorflow/KMP用于网页内容匹配.py
new file mode 100755
index 0000000..e83bdac
--- /dev/null
+++ b/gzy/tesorflow/KMP用于网页内容匹配.py
@@ -0,0 +1,24 @@
+
+nexts = [0]*100
+x = '<img class="ui image bqppsearch lazy" data-original="'
+
+def KMPinit():
+    i,j,m = 0,-1,len(x)
+    nexts[0]=-1
+    while i<m:
+        while j!=-1 and x[i]!=x[j]: j=nexts[j]
+        nexts[i+1]=j+1
+        i,j=i+1,j+1
+
+def findWord(y):
+    i,j,ans,n,m=0,0,[],len(y),len(x)
+    while i<n:
+        while j!=-1 and y[i]!=x[j]: j=nexts[j]
+        i,j=i+1,j+1
+        if j==m:
+            to = i+1
+            while y[to:to+7]!='\" title': to=to+1
+            if y[to-3:to]=='jpg' and y[i]=='h' :ans.append(y[i:to])
+            j=nexts[j]
+    return ans
+
diff --git a/gzy/tesorflow/LeNet.py b/gzy/tesorflow/LeNet.py
new file mode 100755
index 0000000..7270a74
--- /dev/null
+++ b/gzy/tesorflow/LeNet.py
@@ -0,0 +1,68 @@
+import tensorflow as tf
+from tensorflow.examples.tutorials.mnist import input_data
+
+def weight_variable(shape):
+    initial = tf.truncated_normal(shape,stddev=0.1)
+    return tf.Variable(initial)
+
+def bias_variable(shape):
+    initial = tf.constant(0,1,shape=shape)
+    return tf.Variable(initial)
+
+def conv2d(x,W):
+    return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')
+
+def max_pool_2x2(x):
+    return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
+
+
+# 预处理
+mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
+xs = tf.placeholder(tf.float32,[None,784])
+ys = tf.placeholder(tf.float32,[None,10])
+keep_prob = tf.placeholder(tf.float32)
+
+# 第一层卷积
+W_conv1 = weight_variable([5,5,1,32])
+b_conv1 = bias_variable([32])
+x_image = tf.reshape(xs,[-1,28,28,1])
+h_conv1 = tf.nn.relu(conv2d(x_image,W_conv1)+b_conv1)
+h_pool1 = max_pool_2x2(h_conv1)
+
+# 第二层卷积
+W_conv2 = weight_variable([5,5,32,64])
+b_conv2 = bias_variable([64])
+h_conv2 = tf.nn.relu(conv2d(h_pool1,W_conv2)+b_conv2)
+h_pool2 = max_pool_2x2(h_conv2)
+
+# 第一层全连接层
+W_fc1 = weight_variable([7*7*64,1024])
+b_fc1 = bias_variable([1024])
+h_pool2_flat = tf.reshape(h_pool2,[-1,7*7*64])
+h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat,W_fc1)+b_fc1)
+h_fc1_drop = tf.nn.dropout(h_fc1,keep_prob)
+
+# 第二层全连接层
+W_fc2 = weight_variable([1024,10])
+b_fc2 = bias_variable([10])
+y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop,W_fc2)+b_fc2)
+
+# 训练模型
+cross_entropy = -tf.reduce_sum(ys*tf.log(y_conv))
+train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
+
+# 概率计算
+correct_prediction = tf.equal(tf.argmax(y_conv,1),tf.argmax(ys,1))
+accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
+
+init = tf.initialize_all_variables()
+sess = tf.Session()
+sess.run(init)
+
+for i in range(2001):
+    batch = mnist.train.next_batch(50)
+    sess.run(train_step,feed_dict={xs:batch[0],ys:batch[1],keep_prob:0.5})
+
+    if i%100==0:
+        tests = mnist.test.next_batch(200)
+        print(sess.run(accuracy,feed_dict={xs:tests[0],ys:tests[1],keep_prob:1.0}))
\ No newline at end of file
diff --git a/gzy/tesorflow/mnist简单全连接神经网络.py b/gzy/tesorflow/mnist简单全连接神经网络.py
new file mode 100755
index 0000000..d6d0cf9
--- /dev/null
+++ b/gzy/tesorflow/mnist简单全连接神经网络.py
@@ -0,0 +1,26 @@
+import tensorflow as tf
+from tensorflow.examples.tutorials.mnist import input_data
+
+mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
+
+xs = tf.placeholder(tf.float32,[None,784])
+ys = tf.placeholder(tf.float32,[None,10])
+
+Weight = tf.Variable(tf.zeros([784,10]))
+biases = tf.Variable(tf.zeros([10]))
+y = tf.nn.softmax(tf.matmul(xs,Weight)+biases)
+
+loss = -tf.reduce_sum(ys*tf.log(y))
+train = tf.train.GradientDescentOptimizer(0.01).minimize(loss)
+
+init = tf.initialize_all_variables()
+sess = tf.Session()
+sess.run(init)
+
+for step in range(10000):
+    batch = mnist.train.next_batch(100)
+    sess.run(train,feed_dict={xs:batch[0],ys:batch[1]})
+    if step%50==0:
+        correct_prediction = tf.equal(tf.arg_max(ys,1),tf.arg_max(y,1))
+        accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
+        print(sess.run(accuracy,feed_dict={xs:mnist.test.images,ys:mnist.test.labels}))
\ No newline at end of file
diff --git a/gzy/tesorflow/一层神经网络预测.py b/gzy/tesorflow/一层神经网络预测.py
new file mode 100755
index 0000000..d6d0cf9
--- /dev/null
+++ b/gzy/tesorflow/一层神经网络预测.py
@@ -0,0 +1,26 @@
+import tensorflow as tf
+from tensorflow.examples.tutorials.mnist import input_data
+
+mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
+
+xs = tf.placeholder(tf.float32,[None,784])
+ys = tf.placeholder(tf.float32,[None,10])
+
+Weight = tf.Variable(tf.zeros([784,10]))
+biases = tf.Variable(tf.zeros([10]))
+y = tf.nn.softmax(tf.matmul(xs,Weight)+biases)
+
+loss = -tf.reduce_sum(ys*tf.log(y))
+train = tf.train.GradientDescentOptimizer(0.01).minimize(loss)
+
+init = tf.initialize_all_variables()
+sess = tf.Session()
+sess.run(init)
+
+for step in range(10000):
+    batch = mnist.train.next_batch(100)
+    sess.run(train,feed_dict={xs:batch[0],ys:batch[1]})
+    if step%50==0:
+        correct_prediction = tf.equal(tf.arg_max(ys,1),tf.arg_max(y,1))
+        accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
+        print(sess.run(accuracy,feed_dict={xs:mnist.test.images,ys:mnist.test.labels}))
\ No newline at end of file
diff --git a/gzy/tesorflow/分辨率归一化+灰度处理.py b/gzy/tesorflow/分辨率归一化+灰度处理.py
new file mode 100755
index 0000000..dbe74f4
--- /dev/null
+++ b/gzy/tesorflow/分辨率归一化+灰度处理.py
@@ -0,0 +1,24 @@
+import os
+from PIL import Image
+
+PATH = 'D:/tensorflow/未处理的训练源/'
+PATH2 = 'D:/tensorflow/train/'
+
+def resize_image(img_path,save_path):
+    total = 0
+    try:
+       for pic in os.listdir(img_path):
+           path = img_path+pic
+           image = Image.open(path).convert('L')
+           new_pic = image.resize((60,60),Image.ANTIALIAS)
+           new_path = save_path+str(total)+'.jpg'
+           new_pic.save(new_path,quality=100)
+           total = total+1
+
+    except Exception as e:
+        print(e)
+
+if __name__ == '__main__':
+    for page in range(1,6):
+        print("During deal with %d"%(page))
+        resize_image(PATH+str(page)+'/',PATH2+str(page)+'/')
\ No newline at end of file
diff --git a/gzy/tesorflow/改进后的训练模型.py b/gzy/tesorflow/改进后的训练模型.py
new file mode 100755
index 0000000..61a6261
--- /dev/null
+++ b/gzy/tesorflow/改进后的训练模型.py
@@ -0,0 +1,186 @@
+# -*- coding=UTF-8 -*-
+import os
+import tensorflow as tf
+import numpy as np
+import time
+from PIL import Image
+
+w = 64
+h = 64
+c = 3
+TOTAL_TYPE = 5
+
+path = 'D:/tensorflow/imgaes/'
+model_path='D:/tensorflow/saver/model.ckpt'
+
+def read_source():
+    imgs,labels = [],[]
+    for dir in os.listdir(path):
+        idx = int(dir)
+        folder = os.path.join(path,dir)
+        zeros = np.zeros(TOTAL_TYPE)
+        zeros[idx]=1
+        print("folder :%s"%(folder))
+        total = 0
+        for f in os.listdir(folder):
+            file = os.path.join(folder,f)
+            image = Image.open(file).convert('RGB').resize((w, h), Image.ANTIALIAS)
+            arr = np.asarray(image)
+            imgs.append(arr)
+            labels.append(zeros)
+            total += 1
+        print(total)
+    return np.asarray(imgs,np.float32),np.asarray(labels,np.int32)
+
+data,label=read_source()
+num_example = data.shape[0]
+arr = np.arange(num_example)
+np.random.shuffle(arr)
+data = data[arr]
+label = label[arr]
+
+# 将所有数据分为训练集和验证集
+ratio = 0.8
+s = np.int(num_example * ratio)
+x_train = data[:s]
+y_train = label[:s]
+x_val = data[s:]
+y_val = label[s:]
+
+
+# -----------------构建网络----------------------
+x = tf.placeholder(tf.float32, shape=[None, w, h, 3], name='x')
+y_ = tf.placeholder(tf.float32, shape=[None,5 ], name='y_')
+
+
+def inference(input_tensor, train, regularizer):
+    with tf.variable_scope('layer1-conv1'):
+        conv1_weights = tf.get_variable("weight", [5, 5, 3, 64],
+                                        initializer=tf.truncated_normal_initializer(stddev=0.1))
+        conv1_biases = tf.get_variable("bias", [64], initializer=tf.constant_initializer(0.0))
+        conv1 = tf.nn.conv2d(input_tensor, conv1_weights, strides=[1, 1, 1, 1], padding='SAME')
+        relu1 = tf.nn.relu(tf.nn.bias_add(conv1, conv1_biases))
+        relu1 = tf.layers.batch_normalization(relu1,training=train)
+
+    with tf.name_scope("layer2-pool1"):
+        pool1 = tf.nn.max_pool(relu1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="SAME")
+
+    with tf.variable_scope("layer3-conv2"):
+        conv2_weights = tf.get_variable("weight", [3, 3, 64, 128],
+                                        initializer=tf.truncated_normal_initializer(stddev=0.1))
+        conv2_biases = tf.get_variable("bias", [128], initializer=tf.constant_initializer(0.0))
+        conv2 = tf.nn.conv2d(pool1, conv2_weights, strides=[1, 1, 1, 1], padding='SAME')
+        relu2 = tf.nn.relu(tf.nn.bias_add(conv2, conv2_biases))
+        relu2 = tf.layers.batch_normalization(relu2, training=train)
+
+    with tf.name_scope("layer4-pool2"):
+        pool2 = tf.nn.max_pool(relu2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
+
+    with tf.variable_scope("layer5-conv3"):
+        conv3_weights = tf.get_variable("weight", [3, 3, 128, 256],
+                                        initializer=tf.truncated_normal_initializer(stddev=0.1))
+        conv3_biases = tf.get_variable("bias", [256], initializer=tf.constant_initializer(0.0))
+        conv3 = tf.nn.conv2d(pool2, conv3_weights, strides=[1, 1, 1, 1], padding='SAME')
+        relu3 = tf.nn.relu(tf.nn.bias_add(conv3, conv3_biases))
+        relu3 = tf.layers.batch_normalization(relu3, training=train)
+
+
+    with tf.name_scope("layer8-pool4"):
+        pool4 = tf.nn.max_pool(relu3, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
+        norm4 = tf.nn.lrn(pool4, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75)
+        nodes = 8 * 8* 256
+        reshaped = tf.reshape(norm4, [-1, nodes])
+
+    with tf.variable_scope('layer9-fc1'):
+        fc1_weights = tf.get_variable("weight", [nodes, 1024],
+                                      initializer=tf.truncated_normal_initializer(stddev=0.1))
+        if regularizer != None: tf.add_to_collection('losses', regularizer(fc1_weights))
+        fc1_biases = tf.get_variable("bias", [1024], initializer=tf.constant_initializer(0.1))
+
+        fc1 = tf.nn.relu(tf.matmul(reshaped, fc1_weights) + fc1_biases)
+        if train: fc1 = tf.nn.dropout(fc1, 0.8)
+
+    with tf.variable_scope('layer10-fc2'):
+        fc2_weights = tf.get_variable("weight", [1024, 512],
+                                      initializer=tf.truncated_normal_initializer(stddev=0.1))
+        if regularizer != None: tf.add_to_collection('losses', regularizer(fc2_weights))
+        fc2_biases = tf.get_variable("bias", [512], initializer=tf.constant_initializer(0.1))
+
+        fc2 = tf.nn.relu(tf.matmul(fc1, fc2_weights) + fc2_biases)
+        if train: fc2 = tf.nn.dropout(fc2, 0.8)
+
+    with tf.variable_scope('layer11-fc3'):
+        fc3_weights = tf.get_variable("weight", [512, 5],
+                                      initializer=tf.truncated_normal_initializer(stddev=0.1))
+        if regularizer != None: tf.add_to_collection('losses', regularizer(fc3_weights))
+        fc3_biases = tf.get_variable("bias", [5], initializer=tf.constant_initializer(0.1))
+        logit = tf.matmul(fc2, fc3_weights) + fc3_biases
+
+    return logit
+
+
+# ---------------------------网络结束---------------------------
+regularizer = tf.contrib.layers.l2_regularizer(0.0001)
+logits = inference(x, False, regularizer)
+
+# (小处理)将logits乘以1赋值给logits_eval，定义name，方便在后续调用模型时通过tensor名字调用输出tensor
+b = tf.constant(value=1, dtype=tf.float32)
+logits_eval = tf.multiply(logits, b, name='logits_eval')
+
+# loss = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=y_)
+# loss = -tf.reduce_sum(y_*tf.log(logits))
+loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=logits,labels=y_))
+update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
+with tf.control_dependencies(update_ops):
+    train_op = tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss)
+correct_prediction = tf.equal(tf.argmax(logits, 1),tf.argmax(y_,1))
+acc = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
+
+
+# 定义一个函数，按批次取数据
+def minibatches(inputs=None, targets=None, batch_size=None, shuffle=False):
+    assert len(inputs) == len(targets)
+    if shuffle:
+        indices = np.arange(len(inputs))
+        np.random.shuffle(indices)
+    for start_idx in range(0, len(inputs) - batch_size + 1, batch_size):
+        if shuffle:
+            excerpt = indices[start_idx:start_idx + batch_size]
+        else:
+            excerpt = slice(start_idx, start_idx + batch_size)
+        yield inputs[excerpt], targets[excerpt]
+
+
+# 训练和测试数据，可将n_epoch设置更大一些
+
+
+n_epoch = 200
+batch_size = 64
+saver = tf.train.Saver()
+sess = tf.Session()
+sess.run(tf.global_variables_initializer())
+for epoch in range(n_epoch):
+    start_time = time.time()
+
+    # training
+    train_loss, train_acc, n_batch = 0, 0, 0
+    for x_train_a, y_train_a in minibatches(x_train, y_train, batch_size, shuffle=True):
+        _, err, ac = sess.run([train_op, loss, acc], feed_dict={x: x_train_a, y_: y_train_a})
+        train_loss += err;
+        train_acc += ac;
+        n_batch += 1
+    print("   train loss: %f" % (np.sum(train_loss) / n_batch))
+    print("   train acc: %f" % (np.sum(train_acc) / n_batch))
+
+    # validation
+    val_loss, val_acc, n_batch = 0, 0, 0
+    for x_val_a, y_val_a in minibatches(x_val, y_val, batch_size, shuffle=False):
+        err, ac = sess.run([loss, acc], feed_dict={x: x_val_a, y_: y_val_a})
+        val_loss += err
+        val_acc += ac
+        n_batch += 1
+    print("   validation loss: %f" % (np.sum(val_loss) / n_batch))
+    print("   validation acc: %f" % (np.sum(val_acc) / n_batch))
+saver.save(sess,model_path)
+sess.close()
+
diff --git a/gzy/tesorflow/爬取网页图片.py b/gzy/tesorflow/爬取网页图片.py
new file mode 100755
index 0000000..b325410
--- /dev/null
+++ b/gzy/tesorflow/爬取网页图片.py
@@ -0,0 +1,22 @@
+import requests
+import KMP
+
+url = 'https://fabiaoqing.com/search/search/keyword/%E4%BA%8C%E6%AC%A1%E5%85%83%E5%A6%B9%E5%AD%90/type/bq/page/'
+store_path = 'D://tensorflow//萌妹子//'
+
+
+KMP.KMPinit()
+total = 0
+file = store_path
+for page in range(1,20):
+    pages = url+str(page)+'.html'
+    response = requests.get(pages)
+    Word = KMP.findWord(response.text)
+    num = len(Word)
+    for step in range(num):
+        saver = requests.get(Word[step]).content
+        hander=open(store_path+str(total)+'.jpg','wb')
+        hander.write(saver)
+        hander.close()
+        total = total+1
+    print("At Page :%d %d %d"%(page,num,total))
\ No newline at end of file
diff --git a/gzy/tesorflow/生成验证码.py b/gzy/tesorflow/生成验证码.py
new file mode 100755
index 0000000..8d2aff9
--- /dev/null
+++ b/gzy/tesorflow/生成验证码.py
@@ -0,0 +1,39 @@
+import os
+import time
+import random
+import shutil
+from captcha.image import ImageCaptcha
+
+CHAR_SET = ['0','1','2','3','4','5','6','7','8','9']
+CHAR_SET_LEN = 10
+CAPTCHA_LEN = 4
+
+
+CAPTCHA_IMAGE_PATH = 'D:/tensorflow/captcha/images/'
+TEST_IMAGE_PATH = 'D:/tensorflow/captcha/test/'
+TEST_CASE = 200
+
+def generate_captcha_image(PATH):
+    image = ImageCaptcha()
+    for i in range(10):
+        for j in range(10):
+            for k in range(10):
+                for z in range(10):
+                    cap_text = CHAR_SET[i]+CHAR_SET[j]+CHAR_SET[k]+CHAR_SET[z]
+                    image.write(cap_text,PATH+cap_text+'.jpg')
+    print("Finish Write!")
+
+def generate_test_image():
+    fileNameList = []
+    for filePath in os.listdir(CAPTCHA_IMAGE_PATH):
+        captcha_name = filePath.split('/')[-1]
+        fileNameList.append(captcha_name)
+    random.seed(time.time())
+    random.shuffle(fileNameList)
+    for i in range(TEST_CASE):
+        name = fileNameList[i]
+        shutil.move(CAPTCHA_IMAGE_PATH + name, TEST_IMAGE_PATH + name)
+
+if __name__ == '__main__':
+    generate_captcha_image(CAPTCHA_IMAGE_PATH)
+    generate_test_image()
\ No newline at end of file
diff --git a/gzy/tesorflow/训练模型.py b/gzy/tesorflow/训练模型.py
new file mode 100755
index 0000000..7780b69
--- /dev/null
+++ b/gzy/tesorflow/训练模型.py
@@ -0,0 +1,195 @@
+import glob
+import os
+import tensorflow as tf
+import numpy as np
+import time
+from PIL import Image
+
+#数据集地址
+path='D:/tensorflow/imgaes/'
+#模型保存地址
+model_path='D:/tensorflow/saver/model.ckpt'
+
+#将所有的图片resize成100*100
+w=100
+h=100
+c=3
+
+
+#读取图片
+def read_img(path):
+    cate=[path+x for x in os.listdir(path) if os.path.isdir(path+x)]
+    imgs=[]
+    labels=[]
+    for idx,folder in enumerate(cate):
+        print("folder :%s"%(folder))
+        total = 0
+        zero = np.zeros(5)
+        zero[int(idx)]=1
+        for im in glob.glob(folder+'/*.jpg'):
+            # print('reading the images:%s'%(im))
+            image = Image.open(im).convert('RGB')
+            img = image.resize((w, h), Image.ANTIALIAS)
+            arr = np.asarray(img, dtype="float32")
+            imgs.append(arr)
+            labels.append(zero)
+            total = total + 1
+        print(total)
+    return np.asarray(imgs, np.float32), np.asarray(labels, np.float32)
+
+# 好骚的操作啊
+data,label=read_img(path)
+num_example = data.shape[0]
+arr = np.arange(num_example)
+np.random.shuffle(arr)
+data = data[arr]
+label = label[arr]
+
+# 将所有数据分为训练集和验证集
+ratio = 0.8
+s = np.int(num_example * ratio)
+x_train = data[:s]
+y_train = label[:s]
+x_val = data[s:]
+y_val = label[s:]
+
+print(x_val.shape)
+print(y_val.shape)
+
+# -----------------构建网络----------------------
+x = tf.placeholder(tf.float32, shape=[None, w, h, c], name='x')
+y_ = tf.placeholder(tf.float32, shape=[None,5 ], name='y_')
+
+
+def inference(input_tensor, train, regularizer):
+    with tf.variable_scope('layer1-conv1'):
+        conv1_weights = tf.get_variable("weight", [5, 5, 3, 32],
+                                        initializer=tf.truncated_normal_initializer(stddev=0.1))
+        conv1_biases = tf.get_variable("bias", [32], initializer=tf.constant_initializer(0.0))
+        conv1 = tf.nn.conv2d(input_tensor, conv1_weights, strides=[1, 1, 1, 1], padding='SAME')
+        relu1 = tf.nn.relu(tf.nn.bias_add(conv1, conv1_biases))
+
+    with tf.name_scope("layer2-pool1"):
+        pool1 = tf.nn.max_pool(relu1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="VALID")
+
+    with tf.variable_scope("layer3-conv2"):
+        conv2_weights = tf.get_variable("weight", [5, 5, 32, 64],
+                                        initializer=tf.truncated_normal_initializer(stddev=0.1))
+        conv2_biases = tf.get_variable("bias", [64], initializer=tf.constant_initializer(0.0))
+        conv2 = tf.nn.conv2d(pool1, conv2_weights, strides=[1, 1, 1, 1], padding='SAME')
+        relu2 = tf.nn.relu(tf.nn.bias_add(conv2, conv2_biases))
+
+    with tf.name_scope("layer4-pool2"):
+        pool2 = tf.nn.max_pool(relu2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='VALID')
+
+    with tf.variable_scope("layer5-conv3"):
+        conv3_weights = tf.get_variable("weight", [3, 3, 64, 128],
+                                        initializer=tf.truncated_normal_initializer(stddev=0.1))
+        conv3_biases = tf.get_variable("bias", [128], initializer=tf.constant_initializer(0.0))
+        conv3 = tf.nn.conv2d(pool2, conv3_weights, strides=[1, 1, 1, 1], padding='SAME')
+        relu3 = tf.nn.relu(tf.nn.bias_add(conv3, conv3_biases))
+
+    with tf.name_scope("layer6-pool3"):
+        pool3 = tf.nn.max_pool(relu3, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='VALID')
+
+    with tf.variable_scope("layer7-conv4"):
+        conv4_weights = tf.get_variable("weight", [3, 3, 128, 128],
+                                        initializer=tf.truncated_normal_initializer(stddev=0.1))
+        conv4_biases = tf.get_variable("bias", [128], initializer=tf.constant_initializer(0.0))
+        conv4 = tf.nn.conv2d(pool3, conv4_weights, strides=[1, 1, 1, 1], padding='SAME')
+        relu4 = tf.nn.relu(tf.nn.bias_add(conv4, conv4_biases))
+
+    with tf.name_scope("layer8-pool4"):
+        pool4 = tf.nn.max_pool(relu4, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='VALID')
+        nodes = 6 * 6 * 128
+        reshaped = tf.reshape(pool4, [-1, nodes])
+
+    with tf.variable_scope('layer9-fc1'):
+        fc1_weights = tf.get_variable("weight", [nodes, 1024],
+                                      initializer=tf.truncated_normal_initializer(stddev=0.1))
+        if regularizer != None: tf.add_to_collection('losses', regularizer(fc1_weights))
+        fc1_biases = tf.get_variable("bias", [1024], initializer=tf.constant_initializer(0.1))
+
+        fc1 = tf.nn.relu(tf.matmul(reshaped, fc1_weights) + fc1_biases)
+        if train: fc1 = tf.nn.dropout(fc1, 0.5)
+
+    with tf.variable_scope('layer10-fc2'):
+        fc2_weights = tf.get_variable("weight", [1024, 512],
+                                      initializer=tf.truncated_normal_initializer(stddev=0.1))
+        if regularizer != None: tf.add_to_collection('losses', regularizer(fc2_weights))
+        fc2_biases = tf.get_variable("bias", [512], initializer=tf.constant_initializer(0.1))
+
+        fc2 = tf.nn.relu(tf.matmul(fc1, fc2_weights) + fc2_biases)
+        if train: fc2 = tf.nn.dropout(fc2, 0.5)
+
+    with tf.variable_scope('layer11-fc3'):
+        fc3_weights = tf.get_variable("weight", [512, 5],
+                                      initializer=tf.truncated_normal_initializer(stddev=0.1))
+        if regularizer != None: tf.add_to_collection('losses', regularizer(fc3_weights))
+        fc3_biases = tf.get_variable("bias", [5], initializer=tf.constant_initializer(0.1))
+        logit = tf.matmul(fc2, fc3_weights) + fc3_biases
+
+    return logit
+
+
+# ---------------------------网络结束---------------------------
+regularizer = tf.contrib.layers.l2_regularizer(0.0001)
+logits = inference(x, False, regularizer)
+
+# (小处理)将logits乘以1赋值给logits_eval，定义name，方便在后续调用模型时通过tensor名字调用输出tensor
+b = tf.constant(value=1, dtype=tf.float32)
+logits_eval = tf.multiply(logits, b, name='logits_eval')
+
+# loss = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=y_)
+# loss = -tf.reduce_sum(y_*tf.log(logits))
+loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits,labels=y_))
+train_op = tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss)
+correct_prediction = tf.equal(tf.argmax(logits, 1),tf.argmax(y_,1))
+acc = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
+
+
+# 定义一个函数，按批次取数据
+def minibatches(inputs=None, targets=None, batch_size=None, shuffle=False):
+    assert len(inputs) == len(targets)
+    if shuffle:
+        indices = np.arange(len(inputs))
+        np.random.shuffle(indices)
+    for start_idx in range(0, len(inputs) - batch_size + 1, batch_size):
+        if shuffle:
+            excerpt = indices[start_idx:start_idx + batch_size]
+        else:
+            excerpt = slice(start_idx, start_idx + batch_size)
+        yield inputs[excerpt], targets[excerpt]
+
+
+# 训练和测试数据，可将n_epoch设置更大一些
+
+n_epoch = 30
+batch_size = 64
+saver = tf.train.Saver()
+sess = tf.Session()
+sess.run(tf.global_variables_initializer())
+for epoch in range(n_epoch):
+    start_time = time.time()
+
+    # training
+    train_loss, train_acc, n_batch = 0, 0, 0
+    for x_train_a, y_train_a in minibatches(x_train, y_train, batch_size, shuffle=True):
+        _, err, ac = sess.run([train_op, loss, acc], feed_dict={x: x_train_a, y_: y_train_a})
+        train_loss += err;
+        train_acc += ac;
+        n_batch += 1
+    print("   train loss: %f" % (np.sum(train_loss) / n_batch))
+    print("   train acc: %f" % (np.sum(train_acc) / n_batch))
+
+    # validation
+    val_loss, val_acc, n_batch = 0, 0, 0
+    for x_val_a, y_val_a in minibatches(x_val, y_val, batch_size, shuffle=False):
+        err, ac = sess.run([loss, acc], feed_dict={x: x_val_a, y_: y_val_a})
+        val_loss += err;
+        val_acc += ac;
+        n_batch += 1
+    print("   validation loss: %f" % (np.sum(val_loss) / n_batch))
+    print("   validation acc: %f" % (np.sum(val_acc) / n_batch))
+saver.save(sess,model_path)
+sess.close()
\ No newline at end of file
diff --git a/gzy/tesorflow/预测模型.py b/gzy/tesorflow/预测模型.py
new file mode 100755
index 0000000..a23505a
--- /dev/null
+++ b/gzy/tesorflow/预测模型.py
@@ -0,0 +1,57 @@
+import tensorflow as tf
+import numpy as np
+from PIL import Image
+import os
+
+flower_dict = {0:'小熊猫',1:'滑稽',2:'萌妹子',3:'小坏坏',4:'小黄鸡'}
+path = 'C:/Users/yuanshao/Desktop/test/'
+
+w=100
+h=100
+c=3
+
+def read_one_image(path):
+    image = Image.open(path).convert('RGB')
+    img = image.resize((w, h), Image.ANTIALIAS)
+    return np.asarray(img)
+
+def preprocess():
+    count = 0
+    for file in os.listdir(path):
+        new_name = os.path.join(path, str(count))
+        os.rename(os.path.join(path, file),new_name)
+        count += 1
+    for file in os.listdir(path):
+        ori_name = path+file
+        os.rename(ori_name,ori_name+'.jpg')
+
+with tf.Session() as sess:
+    PATH = cate=[path+x for x in os.listdir(path)]
+    data = []
+    pic = []
+    preprocess()
+    for i in range(len(PATH)):
+        picture = path+str(i)+'.jpg';
+        print(picture)
+        pic.append(picture)
+        data.append(read_one_image(picture))
+
+    saver = tf.train.import_meta_graph('D:/tensorflow/saver/model.ckpt.meta')
+    saver.restore(sess,tf.train.latest_checkpoint('D:/tensorflow/saver/'))
+
+    graph = tf.get_default_graph()
+    x = graph.get_tensor_by_name("x:0")
+
+    logits = graph.get_tensor_by_name("logits_eval:0")
+
+    classification_result = sess.run(logits,feed_dict={x:data})
+
+    #打印出预测矩阵
+    print(classification_result)
+    #打印出预测矩阵每一行最大值的索引
+    print(tf.argmax(classification_result,1).eval())
+    output = []
+    output = tf.argmax(classification_result,1).eval()
+    for i in range(len(output)):
+        print("第",i,"张图片预测:"+flower_dict[output[i]])
+
diff --git a/gzy/tesorflow/验证码识别模型训练.py b/gzy/tesorflow/验证码识别模型训练.py
new file mode 100755
index 0000000..7eafe9f
--- /dev/null
+++ b/gzy/tesorflow/验证码识别模型训练.py
@@ -0,0 +1,209 @@
+import tensorflow as tf
+from captcha.image import  ImageCaptcha
+import numpy as np
+import matplotlib.pyplot as plt
+from PIL import  Image
+import random
+
+number=['0','1','2','3','4','5','6','7','8','9']
+#alphabet = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
+#ALPHABET = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
+
+def random_captcha_text(char_set=number,captcha_size=4):
+    captcha_text=[]
+    for i in range(captcha_size):
+        c=random.choice(char_set)
+        captcha_text.append(c)
+    return captcha_text
+
+def gen_captcha_text_image():
+    image=ImageCaptcha()
+    captcha_text=random_captcha_text()
+    captcha_text=''.join(captcha_text)
+    captcha=image.generate(captcha_text)
+    captcha_image=Image.open(captcha)
+    captcha_image=np.array(captcha_image)
+    return captcha_text,captcha_image
+
+
+def convert2gray(img):
+    if len(img.shape)>2:
+        r, g, b = img[:, :, 0], img[:, :, 1], img[:, :, 2]
+        gray = 0.2989 * r + 0.5870 * g + 0.1140 * b
+        return gray
+    else:
+        return img
+
+
+def text2vec(text):
+    text_len = len(text)
+    if text_len > max_captcha:
+        raise ValueError('验证码最长4个字符')
+
+    vector = np.zeros(max_captcha * char_set_len)
+
+    def char2pos(c):
+        if c == '_':
+            k = 62
+            return k
+        k = ord(c) - 48
+        if k > 9:
+            k = ord(c) - 55
+            if k > 35:
+                k = ord(c) - 61
+                if k > 61:
+                    raise ValueError('No Map')
+        return k
+
+    for i, c in enumerate(text):
+        idx = i * char_set_len + char2pos(c)
+        vector[idx] = 1
+    return vector
+
+
+def get_next_batch(batch_size=128):
+    batch_x=np.zeros([batch_size,image_height*image_width])
+    batch_y=np.zeros([batch_size,max_captcha*char_set_len])
+
+    def wrap_gen_captcha_text_and_image():
+        while True:
+            text, image = gen_captcha_text_image()
+            if image.shape == (60, 160, 3):
+                return text, image
+
+    for i in range(batch_size):
+        text, image = wrap_gen_captcha_text_and_image()
+        image = convert2gray(image)
+
+        batch_x[i, :] = image.flatten() / 255
+        batch_y[i, :] = text2vec(text)
+
+    return batch_x, batch_y
+
+def cnn_structure(w_alpha=0.01, b_alpha=0.1):
+    x = tf.reshape(X, shape=[-1, image_height, image_width, 1])
+
+
+    wc1=tf.get_variable(name='wc1',shape=[3,3,1,32],dtype=tf.float32,initializer=tf.contrib.layers.xavier_initializer())
+    #wc1 = tf.Variable(w_alpha * tf.random_normal([3, 3, 1, 32]))
+    bc1 = tf.Variable(b_alpha * tf.random_normal([32]))
+    conv1 = tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(x, wc1, strides=[1, 1, 1, 1], padding='SAME'), bc1))
+    conv1 = tf.nn.max_pool(conv1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
+    conv1 = tf.nn.dropout(conv1, keep_prob)
+
+    wc2=tf.get_variable(name='wc2',shape=[3,3,32,64],dtype=tf.float32,initializer=tf.contrib.layers.xavier_initializer())
+   # wc2 = tf.Variable(w_alpha * tf.random_normal([3, 3, 32, 64]))
+    bc2 = tf.Variable(b_alpha * tf.random_normal([64]))
+    conv2 = tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(conv1, wc2, strides=[1, 1, 1, 1], padding='SAME'), bc2))
+    conv2 = tf.nn.max_pool(conv2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
+    conv2 = tf.nn.dropout(conv2, keep_prob)
+
+    wc3=tf.get_variable(name='wc3',shape=[3,3,64,128],dtype=tf.float32,initializer=tf.contrib.layers.xavier_initializer())
+    #wc3 = tf.Variable(w_alpha * tf.random_normal([3, 3, 64, 128]))
+    bc3 = tf.Variable(b_alpha * tf.random_normal([128]))
+    conv3 = tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(conv2, wc3, strides=[1, 1, 1, 1], padding='SAME'), bc3))
+    conv3 = tf.nn.max_pool(conv3, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
+    conv3 = tf.nn.dropout(conv3, keep_prob)
+
+
+    wd1=tf.get_variable(name='wd1',shape=[8*20*128,1024],dtype=tf.float32,initializer=tf.contrib.layers.xavier_initializer())
+    #wd1 = tf.Variable(w_alpha * tf.random_normal([7*20*128,1024]))
+    bd1 = tf.Variable(b_alpha * tf.random_normal([1024]))
+    dense = tf.reshape(conv3, [-1, wd1.get_shape().as_list()[0]])
+    dense = tf.nn.relu(tf.add(tf.matmul(dense, wd1), bd1))
+    dense = tf.nn.dropout(dense, keep_prob)
+
+    wout=tf.get_variable('name',shape=[1024,max_captcha * char_set_len],dtype=tf.float32,initializer=tf.contrib.layers.xavier_initializer())
+    #wout = tf.Variable(w_alpha * tf.random_normal([1024, max_captcha * char_set_len]))
+    bout = tf.Variable(b_alpha * tf.random_normal([max_captcha * char_set_len]))
+    out = tf.add(tf.matmul(dense, wout), bout)
+    return out
+
+def train_cnn():
+    output=cnn_structure()
+    cost=tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=output,labels=Y))
+    optimizer=tf.train.AdamOptimizer(learning_rate=0.001).minimize(cost)
+    predict=tf.reshape(output,[-1,max_captcha,char_set_len])
+    max_idx_p = tf.argmax(predict, 2)
+    max_idx_l = tf.argmax(tf.reshape(Y, [-1, max_captcha, char_set_len]), 2)
+    correct_pred = tf.equal(max_idx_p, max_idx_l)
+    accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
+
+    saver=tf.train.Saver()
+
+    with tf.Session() as sess:
+        init = tf.global_variables_initializer()
+        sess.run(init)
+        step = 0
+        while True:
+            batch_x, batch_y = get_next_batch(100)
+            _, cost_= sess.run([optimizer, cost], feed_dict={X: batch_x, Y: batch_y, keep_prob: 0.75})
+            print(step, cost_)
+            if step % 10 == 0:
+                batch_x_test, batch_y_test = get_next_batch(100)
+                acc = sess.run(accuracy, feed_dict={X: batch_x_test, Y: batch_y_test, keep_prob: 1.})
+                print(step, acc)
+                if acc > 0.99:
+                    saver.save(sess, "./model/crack_capcha.model", global_step=step)
+                    break
+            step += 1
+
+
+def crack_captcha(captcha_image):
+    output = cnn_structure()
+
+    saver = tf.train.Saver()
+    with tf.Session() as sess:
+        saver.restore(sess, "./model/crack_capcha.model-1200")
+
+        predict = tf.argmax(tf.reshape(output, [-1, max_captcha, char_set_len]), 2)
+        text_list = sess.run(predict, feed_dict={X: [captcha_image], keep_prob: 1.})
+        text = text_list[0].tolist()
+        return text
+
+if __name__=='__main__':
+    train=1
+    if train==0:
+        text,image=gen_captcha_text_image()
+        print("验证码大小：",image.shape)#(60,160,3)
+
+        image_height=60
+        image_width=160
+        max_captcha=len(text)
+        print("验证码文本最长字符数",max_captcha)
+        char_set=number
+        char_set_len=len(char_set)
+
+        X = tf.placeholder(tf.float32, [None, image_height * image_width])
+        Y = tf.placeholder(tf.float32, [None, max_captcha * char_set_len])
+        keep_prob = tf.placeholder(tf.float32)
+        train_cnn()
+
+    if train == 1:
+        image_height = 60
+        image_width = 160
+        char_set = number
+        char_set_len = len(char_set)
+
+        text, image = gen_captcha_text_image()
+
+        f = plt.figure()
+        ax = f.add_subplot(111)
+        ax.text(0.1, 0.9, text, ha='center', va='center', transform=ax.transAxes)
+        plt.imshow(image)
+
+       # plt.show()
+
+        max_captcha = len(text)
+        image = convert2gray(image)
+        image = image.flatten() / 255
+
+        X = tf.placeholder(tf.float32, [None, image_height * image_width])
+        Y = tf.placeholder(tf.float32, [None, max_captcha * char_set_len])
+        keep_prob = tf.placeholder(tf.float32)
+
+        predict_text = crack_captcha(image)
+        print("正确: {}  预测: {}".format(text, predict_text))
+
+
+        plt.show()
\ No newline at end of file