python深度学习stadardscalar fit_transform数据处理、contrib使用、Session多种创建、in_top_k、argmax、equal、cas、extend map_pythonstandardscaler().fit_transform在做什么

1、StadardScalar()与fit_transform()

  其StadardScalar是去均值和进行方差归一化，其是对数据的每一个特征维度进行的操作，即对所有最小的元素进行操作，而不是针对一个样本。其要完成这个功能需要配合fit_transform()函数进行。

其实例代码如下：

# coding=utf-8
# 统计训练集的 mean 和　std 信息
from sklearn.preprocessing import StandardScaler
import numpy as np
 
 
def test_algorithm():
    np.random.seed(123)
    print('use sklearn')
    # 注：shape of data: [n_samples, n_features]
    data = np.random.randn(10, 4)
    scaler = StandardScaler()
    scaler.fit(data)
    trans_data = scaler.transform(data)
    print('original data: ')
    print data
    print('transformed data: ')
    print trans_data
    print('scaler info: scaler.mean_: {}, scaler.var_: {}'.format(scaler.mean_, scaler.var_))
    print('\n')
 
    print('use numpy by self')
    mean = np.mean(data, axis=0)
    std = np.std(data, axis=0)
    var = std * std
    print('mean: {}, std: {}, var: {}'.format(mean, std, var))
    # numpy 的广播功能
    another_trans_data = data - mean
    # 注：是除以标准差
    another_trans_data = another_trans_data / std
    print('another_trans_data: ')
    print another_trans_data
 
 
if __name__ == '__main__':
    test_algorithm()

其输出数据为：

use sklearn
    original data:
    [[-1.0856306   0.99734545  0.2829785 - 1.50629471]
     [-0.57860025  1.65143654 - 2.42667924 - 0.42891263]
    [1.26593626 - 0.8667404 - 0.67888615 - 0.09470897]
    [1.49138963 - 0.638902 - 0.44398196 - 0.43435128]
    [2.20593008
    2.18678609
    1.0040539
    0.3861864]
    [0.73736858  1.49073203 - 0.93583387  1.17582904]
    [-1.25388067 - 0.6377515
    0.9071052 - 1.4286807]
    [-0.14006872 - 0.8617549 - 0.25561937 - 2.79858911]
    [-1.7715331 - 0.69987723
    0.92746243 - 0.17363568]
    [0.00284592  0.68822271 - 0.87953634  0.28362732]]
    transformed
    data:
    [[-0.94511643  0.58665507  0.5223171 - 0.93064483]
     [-0.53659117  1.16247784 - 2.13366794  0.06768082]
    [0.9495916 - 1.05437488 - 0.42049501
    0.3773612]
    [1.13124423 - 0.85379954 - 0.19024378  0.06264126]
    [1.70696485
    1.63376764
    1.22910949
    0.8229693]
    [0.52371324  1.02100318 - 0.67235312  1.55466934]
    [-1.08067913 - 0.85278672
    1.13408114 - 0.858726]
    [-0.18325687 - 1.04998594 - 0.00561227 - 2.1281129]
    [-1.49776284 - 0.9074785
    1.15403514
    0.30422599]
    [-0.06810748  0.31452186 - 0.61717074  0.72793583]]
    scaler info: scaler.mean_: [0.08737571  0.33094968 - 0.24989369 - 0.50195303], scaler.var_: [1.54038781  1.29032409
                                                                                          1.04082479  1.16464894]
 
    use numpy by self
    mean: [0.08737571  0.33094968 - 0.24989369 - 0.50195303], std: [1.24112361  1.13592433  1.02020821
                                                                    1.07918902], var: [1.54038781  1.29032409
                                                                                       1.04082479  1.16464894]
    another_trans_data:
    [[-0.94511643  0.58665507  0.5223171 - 0.93064483]
     [-0.53659117  1.16247784 - 2.13366794  0.06768082]
    [0.9495916 - 1.05437488 - 0.42049501
    0.3773612]
    [1.13124423 - 0.85379954 - 0.19024378  0.06264126]
    [1.70696485
    1.63376764
    1.22910949
    0.8229693]
    [0.52371324  1.02100318 - 0.67235312  1.55466934]
    [-1.08067913 - 0.85278672
    1.13408114 - 0.858726]
    [-0.18325687 - 1.04998594 - 0.00561227 - 2.1281129]
    [-1.49776284 - 0.9074785
    1.15403514
    0.30422599]
    [-0.06810748  0.31452186 - 0.61717074  0.72793583]]

 

2、tensorflow的第三方库contrib的输入使用方法：

 如果直接通过下面代码使用其里面的函数则会出现无法智能提示的问题：

import tensorflow as tf
initializer = tf.contrib.layers.variance_scaling_initializer()

其解决方法是直接使用下面的代码，则可以智能提示layers里面的函数：

import tensorflow.contrib as contrib
initializer = tf.contrib.layers.variance_scaling_initializer()
initializer=contib.layers.variance_scaling_initializer()

3、Session()会话的多种应用创建方式：

   如果我们想获取网络的过程中的某些tensor变量，则要通过会话来进行获取，然后把tensor转换为我们能处理的array，此时可以使用到的函数是eval()、run().其使用涉及到Session()的创建。下面就是方法：

方法一：

# 改写训练代码
sess = tf.Session()
sess.run(init)
# 要加上这句代码，如果不加的画则下面只能使用run()来运行每一个会话，而不能使用eval()
with sess.as_default():
    init.run()
    for epoch in range(n_epochs):
        n_batches = mnist.train.num_examples // batch_size
        for i in range(n_batches):
            print("\r{}%".format(100*i//n_batches),end='')
            X_train, Y_train = mnist.train.next_batch(batch_size)
            sess.run(training_op, feed_dict={X: X_train})
        # 通过run获去的变量也是一个array，
        # loss_train=sess.run(reconstruction_loss,feed_dict={X:X_train})
        # 此时可以不使用run，直接使用eval，把这个tensor变量转换为array，
        loss_train = reconstruction_loss.eval(feed_dict={X: X_train})
        print("\r{} loss:{}".format(epoch, loss_train))
sess.close()

还有更简洁的代码，方法二：

# 要加上这句代码，如果不加的画则下面只能使用run()来运行每一个会话，而不能使用eval()
with tf.Session() as sess:
    init.run()
    for epoch in range(n_epochs):
        n_batches = mnist.train.num_examples // batch_size
        for i in range(n_batches):
            print("\r{}%".format(100*i//n_batches),end='')
            X_train, Y_train = mnist.train.next_batch(batch_size)
            sess.run(training_op, feed_dict={X: X_train})
        # 通过run获去的变量也是一个array，
        # loss_train=sess.run(reconstruction_loss,feed_dict={X:X_train})
        # 此时可以不使用run，直接使用eval，把这个tensor变量转换为array，
        loss_train = reconstruction_loss.eval(feed_dict={X: X_train})
        print("\r{} loss:{}".format(epoch, loss_train))
# 注释这句，因为使用当Session()离开作用域的时候会自动释放这个Session()
# sess.close()

只能使用run(),而不能使用eval()的方式三：

# 改写训练代码
sess = tf.Session()
sess.run(init)
for epoch in range(n_epochs):
    n_batches = mnist.train.num_examples // batch_size
    for i in range(n_batches):
        print("\r{}%".format(100 * i // n_batches), end='')
        X_train, Y_train = mnist.train.next_batch(batch_size)
        sess.run(training_op, feed_dict={X: X_train})
    # 通过run获去的变量也是一个array，
    loss_train=sess.run(reconstruction_loss,feed_dict={X:X_train})
    # 不能使用这一句，否者会报错
    # loss_train = reconstruction_loss.eval(feed_dict={X: X_train})
    print("\r{} loss:{}".format(epoch, loss_train))
# 要不要这句都无所谓，程序运行完会自动释放
sess.close()

  从上面的方式总结得出：使用sess.run()方法是在每一种形势下都适用。而eval只有在一、二模式下才可以使用。第三种模式会报错。

4、在网络输出的时候计算准确度的方法：

   第一种：是使用in_top_k()函数用来计算logits里的最大top_k里的值的index里有没有跟y想等的值，如果有则是返回True，否则返回False。来进行计算平均准确度，下面是以mnist数据集为例子，其代码如下： 

correct = tf.nn.in_top_k(logits, y, 1)
accuracy = tf.reduce_mean(tf.cast(correct, tf.float32))

上面的y是就是通过

X_train, Y_train = mnist.train.next_batch(n_batch_size)

Y_train传递进来的数据。其是一个0-9的标签值而不是0、1的标签值。这种情况适用于在加载手写字时没用了one_hot参数，其如下：

mnist = input_data.read_data_sets("MNIST_data/")

第二种：在使用了one_hot参数后则其计算准确度的方式为：

 correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(y, 1))
 accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

这时是使用了one_hot参数的情况下的：

 
mnist = input_data.read_data_sets(LOGDIR, one_hot=True)

这时加载的标签值时0、1的。这个时候就需要使用到argmax()函数来进行返回标签的位置，即其输出值跟上面的第一种的y的值一样大小

5、在计算网络准确度的方式使用到的相关函数：

一、tf.argmax()、tf.equal()、tf.cast()

import tensorflow as tf
import numpy as np
 
A = [[1, 3, 4]]
B = [[4, 3, 1]]
 
with tf.Session() as sess:
    # 其中argmax的是返回最大值的index位置从0开始
    print(sess.run(tf.argmax(A, 1)))
    print(sess.run(tf.argmax(B, 1)))
    print(sess.run(tf.equal(A, B)))
    print(sess.run(tf.cast(tf.equal(A, B),dtype=tf.float32)))
    print(sess.run(tf.reduce_mean(tf.cast(tf.equal(A, B), tf.float32))))

其输出结果是：

[2]
[0]
[[False  True False]]
[[0. 1. 0.]]
0.33333334

下面是使用argmax()、max()、extend()、map()等的使用：

import copy
import tensorflow as tf
import numpy as np
import numpy as np
import tensorflow as tf
 
 
def main(labels):
    label = labels
    label_list = []
    for label in labels:
        # extend在label_list后面追加元素，map是对第二个参数的数据使用第一个参数进行对应的操作变化
        label_list.extend(map(int, list(label)))
    #整个数组进行加1操作
    label_list = np.array(label_list) + 1
    print(label_list)
    # 在[0,1]之间产生一个3*3的矩阵
    datas = tf.Variable(tf.random_uniform((3, 3), minval=0, maxval=1))
    with tf.Session() as session:
        #当有声明的tf.Variable变量时，其都需要使用会话来真正初始化变量，tf.initialize_all_variables()，如果没有这句的话，datas变量是可以通过eval()查看到有值，但是此时看到的值并不是这个变量真正的值。从而就导致tf.argmax(datas, axis=1)输出来的index跟实际看到的结果不一致。
        session.run(tf.initialize_all_variables())
        print(datas.eval())
        # 返回datas变量对应维度的最大值index。其一般被用在
        datamax = tf.argmax(datas, axis=1)
        print(datamax.eval())
    # 在[0,1.2]间隔0.2产生一个2*3的矩阵，当无法产生对应矩阵时会报错
    datanp = np.arange(0, 1.2, .2).reshape(2, 3)
    print(datanp)
    datanpmax = np.max(datanp, axis=1) # 维度不一致回报错，返回对应维度的最大值，不是index
    print(datanpmax)
    #这里的max跟上面的np.max的效果一样的
    print(datanp.max(1))
    # print(label_list.type())
    # # 这个方法把一个list直接转换成一个tensor
    # print(torch.IntTensor([18] * int(32)))
 
 
if __name__ == '__main__':
    main([[1, 2, 3, 5, 2, 4]])
 
 
 
 

输出结果为：

[2 3 4 6 3 5]
 
[[0.6428882  0.3081398  0.5051584 ]
 [0.750348   0.9321439  0.9986844 ]
 [0.9667671  0.48763072 0.12574685]]
[0 2 0]
[[0.  0.2 0.4]
 [0.6 0.8 1. ]]
Backend Qt5Agg is interactive backend. Turning interactive mode on.
[0.4 1. ]
[0.4 1. ]