tensorflow 从入门到上天教程一

tensorflow 是一个google开源的深度学习的框架，执行性能良好，值得使用。

caffe，caffe2 通过配置就可以拼凑一个深度学习框架，大大简化流程但也依赖大量的开源库，性能也不错。2013开始面世，很有活力的一个框架。

keras 这个一个积木式的框架，有很多现成的函数 可以直接拿来用，开发速度杠杠的，就是缺少灵活性。

MXNet 是一个全功能,灵活可编程和高扩展性的深度学习框架，可能学术上用的比较多吧！

Torch 是一个facebook在维护的框架，灵活性也很大，不过要lua语言结合使用；

CNTK微软推出的一个深度学习框架，可以在window上执行，性能据说是最优的，可是使用者不多，可能是市场都被主流的几个占有了；

Deeplearning4j java的一个深度学习库，不甚了解；

Theano 是一个很古老的框架，在研究室就开始使用，性能比较差，速度最慢的，生产环境不会用的，只是现在有些研究室还在用。

其他：

SciKit-learn 是老牌的开源 Python 算法框架

openCV 是一个图片及视觉算法的框架

=============================================================

最要建议就是学学：

tensorflow + caffe（caffe2）

其实想深入研究原理也可以简单使用

numpy + matplotlib

===============================================================

tensorflow的运行规律，就是步骤了：

1， 创建tensorflow变量，初始变量，用于执行的的
2， 设置操作的配置
3， 初始化tensorflow 例子
4， 创建tensorflow session （session是执行引擎）
5， 执行session 即运行你的例子

==============================================================

以上是tensorflow使用的一般步骤,接下来就一个线性回归的例子来，我们先分拆各个代码块来讲解，然后把把代码块合并成一个大的例子。在看tensorflow这个例子，你最好有一些深度学习的基础，以免看得一头雾水。

（1） loss函数的计算：

	  y_hat = tf.constant(36,name=’y_hat’)
      y = tf.constant(39,name=’y’)     
      loss = tf.Variable((y-y_hat)**2,name=’loss’)
      init = tf.global_variables_initializer()
      with tf.Session() as session:
          session.run(init)             # 初始化全局变量
          print(session.run(loss))     # 执行计算 打印出最好loss的值

（2） 计算返回的机制

a = tf.constant(2)
b= ft.constant(2)
c=tf.multiply(a,b)
print(c)  # 返回结果 Tensor("Mul_1:0", shape=(), dtype=int32)
sess=tf.session()
print(sess.run(c))  #返回20

（3） 设置容器，然后通过函数赋值，进行计算

x = tf.placeholder(tf.init64,name=’x’)
print(sess.run(2*x,feed_dict={x:3}))  #把字典里的值 赋值给我2*x
sess.close()

===========================================

2，线性回归计算 函数块

2.1 线性函数的计算

Y=WX+b (X:是一个随机变量,b是一个偏差变量)

预说明：
tf.matmul(…,…) 是矩阵阶乘的工具
tf.add(…,…) 矩阵加法函数
np.random.randn(…) 随机生成正太随机数

def linear_function()

    np.random.seed(1)
    X=tf.constant(np.random.randn(3,1)，name=”X”)
    W=tf.constant(np.random.randn(4,3),name=”W”)
     b = tf.constant(np.random.randn(4,1),name=”b”)
    Y=tf.add(tf.matmul(W,X),b)

    Sess = tf.Session()
    result=sess.run(Y)

    sess.close()
    return result
print(“result=”+str(linear_function()))

运行结果：
result = [[-2.15657382]
[ 2.95891446]
[-1.08926781]
[-0.84538042]]

2.2 计算sigmoid

如果你学了深度学习一定知道sigmoid 是什么，其实也是数学里的一个函数：y= 1/(1+e^(-x))

在tensorflow里有专门的sigmoid函数

1） tf.placeholder(tf.float32,name=””)

2） tf.sigmoid(…)

3） sess.run(…,feed_dict={x:z})

方法1 ：

  Sess = tf.Session()

  result =sess.run(…,feed_dict ={…})

  sess.close()

方法2：

 With tf.Session as sess:           #会自动关闭session

 result = sess.run(..,feed_dict = {…})

def sigmoid(z):
    x = tf.placeholder(tf.float32,name = “x”)
    sigmoid = tf.sigmoid(x)

    with tf.Session() as sess:
        result = sess.run(sigmoid,feed_dict = {x:z})

    return result

2.3 损失函数 （成本函数）

在tensorflow 函数里，你可能会用到：

tf.nn.sigmoid_cross_entropy_with_logits(logits=….,lables=…)

def cost(logits,labels):
    z = tf.placeholder(tf.float32,name=”z”)
    y= tf.placeholder(tf.float32,name=”y”)
    cost = tf.nn.sigmoid_cross_entropy_with_logits(logits=z, labels=y)
   sess.close()
   return cost

#测试
logits = sigmoid(np.array([0.2,0.4,0.7,0.9]))
cost = cost(logits, np.array([0,0,1,1]))
print ("cost = " + str(cost))

输出结果：

cost = [ 1.00538719 1.03664076 0.41385433 0.39956617]

2.4 分类映射

把y向量映射成矩阵，然后通过矩阵判断分类，tensorflow有现成的函数：

tf.one_hot(labels,depth,axis)

def one_hot_matrix(labels,C):
       depth = tf.constant(value=C,name=”C”)
       one_hot_matrix = tf.one_hot(labels,depth,axis=0)
       sess = tf.Session()

       one_hot = sess.run(one_hot_matrix)
       sess.close()
       return one_hot

小测：

labels = np.array([1,2,3,0,2,1])
one_hot = one_hot_matrix(labels, C = 4)
print ("one_hot = " + str(one_hot))

2.5 初始化矩阵

tf.ones(shape) 跟 numpy的numpy.ones() 差不多

def ones(shape):
    ones = tf.ones(3)
    sess = tf.Session()
    ones = tf.run(ones)

    sess.close()
    return ones
    print(“ones =”+str(ones([3])))

#输出 ones [1,1,1]

先讲到这里，不想篇幅太长。

参考：吴恩达教学视频及其课件 http://mooc.study.163.com/smartSpec/detail/1001319001.htm