Tensorflow——关于loss

结果：你会发现第一个输出与第三个一致，第二个输出和第四个一致

reduce_sum 是 tensor 内部求和的工具。其参数中：

其实在reduce_sum()中，是从维度上去考虑的（感觉这个Matlab中数据的概念比较像）

调用 reduce_sum(arg1, arg2) 时，参数 arg1 即为要求和的数据， arg2 有两个取值分别为 0 和 1 ，通常用 reduction_indices=[0] 或 reduction_indices=[1] 来传递参数。从上图可以看出，当 arg2 = 0 时，是纵向对矩阵求和，原来矩阵有几列就得到几个值；相似地，当 arg2 = 1 时，是横向对矩阵求和；当省略 arg2 参数时，默认对矩阵所有元素进行求和。

在 reduce_sum() 中就是按照求和的方式对矩阵降维。

计算张量的各个维度上的元素的平均值。

l2_loss一般用于优化目标函数中的正则项，防止参数太多复杂容易过拟合(所谓的过拟合问题是指当一个模型很复杂时，它可以很好的“记忆”每一个训练数据中的随机噪声的部分而忘记了要去“学习”训练数据中通用的趋势)

结果输出：

70

计算的过程:

题外话

正则化的基本思想是向损失函数添加一个惩罚项用于惩罚大的权重，隐式地减少自由参数的数量，所以可以达到d性地适用不同数据量训练的要求而不产生过拟合的问题。

正则化方法是将惩罚因子加入到各层的参数或激活函数中。其实现位置通常是在模型的optimization里，在计算损失函数时将该惩罚因子加进去。

( >

为了在 MXNet、PyTorch 以及 TensorFlow 之间进行互转，本文研究它们之间的基础运算的异同。

对于 MXNet 有 np（numpy）模块和 npx（numpy_extension）模块。np 模块包含了 NumPy 支持的函数。而 npx 模块包含了一组扩展函数，用来在类似 NumPy 的环境中实现深度学习开发。当使用张量时，我们几乎总是会调用 set_np 函数：这是为了兼容 MXNet 其他的张量处理组件。

同样，我们可以将 PyTorch 和 TensorFlow 写作 np ，这样有：

这样 MXNet，TensorFlow 与 PyTorch 有相同的函数：

当然也有许多不同，比如求张量的大小，标准正太分布与张量定义，MXNet：

MXNet，TensorFLow 与 PyTorch 是几乎一致的。

张量的真值、元素求和、拼接：

仔细观察也可以看到细微的不同， nparange 的数据类型的默认值不同，故而，建议：定义张量最好也把 dtype 也指定了。

运行一些 *** 作可能会导致为新结果分配内存。例如，如果我们用 Y = X + Y，我们将取消引用 Y 指向的张量，而是指向新分配的内存处的张量。下面展示了节省内存的方法：

由于 MXNet，TensorFLow 与 PyTorch 均实现了 __array__ ，故而，它们均可直接传入 NumPy 数据到张量。下面仅以 TensorFlow 为例：

这样的好处是，可以直接使用 Matplotlib 画图：

nvidia-smi指令报错：Failed to initialize NVML: Driver解决 - 知乎 (zhihucom)

tensor_name: InceptionResnetV1/Repeat_2/block8_5/Branch_1/Conv2d_0c_3x1/BatchNorm/beta

[ 030647334 -008073353 00034077 021510068 027146173 01675657

026604554 -01032317 011984207 011724642 007620736 012375554

-006992248 013697843 012919003 034591344 036568451 0317754

002724701 -000439289 008131875 017051099 031790206 -009352492

004226211 022472717 -002337432 001546894 031239772 02204784

002757018 036017033 014638098 -005811624 017988347 017746487

-006941296 021333419 017640878 008602006 027483124 00321721

001956727 023703749 007298426 02293691 004570645 010887665

022597478 000326043 020575584 -001400873 01739531 029667068

02858218 024422143 024158308 019234292 -014661171 018738271

023724838 013301046 029720306 -003083316 006878169 046406737

018781497 00624191 03937808 -002187036 020737079 010009278

014728105 017899759 -014871912 01919217 000341381 025338113

009136891 003951717 019825329 021175161 00076494 029722685

-001232735 018481287 032796097 012448999 025752825 -008026847

037497616 -000269843 003891745 036684534 042505971 026376384

022559829 -005736564 -005725395 038400334 018139017 038150936

000968234 -012697321 -003573647 018259619 024792764 034496573

-003927554 017918654 041284841 -014464654 -006818248 035346696

028856903 035986191 -005064728 028079537 002884024 013097511

015112837 012797916 013747489 014481014 007368553 015109707

013464339 004820023 010289188 015790361 026670623 000765492

010244264 016298561 015506735 025534311 -000195114 032599714

004178793 008653457 017778693 013445204 -010189253 023199618

-002996247 015254036 025152346 003849856 010069808 -010080049

034439278 -007660035 006156798 015218045 015133694 005846077

-004273422 -01527732 020916606 024970724 001848394 -008934189

03655096 019509009 037176177 032789144 005016355 -013271447

00126346 015209903 007204891 019686547 0115362 -004414114

037957388 005951164 044415691 029730165 013854508 -014084743

042018226 -002289842 015918387 010486501 -004852037 04353317

033738926 027572519 -011827882 020430365 00749144 -003588741]

tensor_name: InceptionResnetV1/Repeat_2/block8_5/Branch_1/Conv2d_0c_3x1/BatchNorm/moving_mean

[ 014880425 007224792 -007922322 003801934 -002153287 000669256

-004079873 007458529 -000620093 -001715712 003387037 011081664

009121993 00166529 -002508105 003290453 020611584 005986175

-006663642 006174496 -001148917 002036718 001724504 -0027807

006967574 006232886 -010083873 003827187 007497836 003398968

-000222622 -009066853 -005057399 006621534 001469301 -00155831

00775239 004368163 000420791 007296136 008216455 -011976647

006436737 001630144 009064794 -005993644 002662702 -008308787

009903102 00650951 003801294 005821982 006865057 003330573

008873446 -000051568 027659759 006128478 006634127 003950675

012108963 006988253 007311389 006181238 001764684 003492205

005089908 003996143 008789578 -001890574 -002306573 -002459913

011367872 004676843 005660934 000536961 -005392366 012001953

004865452 -006557522 002044297 -002730072 -005313965 005777361

003098485 -000695883 013606462 001830029 006984297 000986209

-001975629 004578528 -000952701 000805499 009874764 0041565

001739479 -006387237 013067035 -000612051 -003732907 012666993

-009587704 -001319821 007010207 005937757 006915031 002067249

005850358 005469967 012346625 015630524 00488473 002964878

008594127 -000559416 -001123399 000498033 -006684806 000930193

-002890788 002198507 007202123 00327589 002186497 005019449

00237705 -001362777 000050911 003228053 00259978 -005748487

004963762 001260684 -001760207 003975213 008374827 002411481

00696357 002075795 -001689599 018679559 011815315 006870342

004349245 -005444571 004443111 -006678601 -004697403 005609457

-000613152 00659774 -008551818 001170648 -005551191 003301272

-003055317 00972893 001789105 004296714 00169957 -000030257

003970404 -000969732 011924396 00239393 000100653 00156338

002764844 00371657 -003620484 -00356607 -004375302 005804532

012778537 005818423 013738503 -003036425 -001796051 -002964116

005724314 013577242 003957674 001596199 -007010525 008297446

-000256824 004166819 000301293 002950976 004688098 002184936]

tensor_name: InceptionResnetV1/Repeat_2/block8_5/Branch_1/Conv2d_0c_3x1/weights

[[[[ -840454269e-03 -411276752e-03 234256196e-03 ,

-300306431e-03 446177274e-03 -733162451e-04]

[ -505736563e-03 454817526e-03 -994976703e-03 ,

-398884574e-03 592243974e-04 -633087417e-04]

[ -260024867e-03 237565581e-03 -164382765e-03 ,

-291683886e-04 -276580267e-03 -359536405e-03]

,

[ 337043940e-03 -341191678e-03 161441125e-03 ,

860486354e-04 107364450e-03 406331819e-04]

[ -657501630e-04 -120706938e-03 -523931719e-03 ,

-430793129e-03 107375933e-02 156657223e-03]

[ 457230862e-03 -312923198e-03 588039926e-04 ,

565426983e-03 721080287e-04 -385465240e-03]]]

[[[ -307337241e-03 297398586e-03 -422048010e-03 ,

853607315e-04 -887657050e-03 -246296171e-04]

[ -213479600e-03 381009164e-03 -693476235e-04 ,

760340411e-03 -758440641e-04 216513639e-03]

[ 194018110e-04 -103318843e-03 496102544e-03 ,

798596162e-03 -453055138e-03 -245945528e-03]

,

[ 256390334e-03 -108171580e-03 -503409980e-03 ,

-190075894e-03 121672056e-03 -218570698e-03]

[ -312542310e-03 -323986821e-03 306262425e-03 ,

-509323459e-03 -101955049e-03 -275188661e-03]

[ -709298206e-03 172719534e-03 195508380e-03 ,

-482927449e-03 -283627072e-03 209987699e-03]]]

[[[ 201998278e-03 -209029677e-05 -767023012e-04 ,

200457731e-03 -737588108e-03 394353177e-03]

[ -839617476e-03 211218139e-03 373103563e-03 ,

301721296e-03 -193046010e-03 177941707e-04]

[ -994210015e-04 -389421987e-03 -398767134e-03 ,

120654888e-03 315538747e-03 -839911588e-03]

,

[ 819853600e-03 -356235774e-03 298067089e-03 ,

969225774e-04 320632593e-03 -141245534e-03]

[ 867560215e-04 -293562305e-03 -447245874e-03 ,

-215201546e-03 237199594e-03 -927432254e-03]

[ 375569449e-03 212926487e-03 -187215116e-03 ,

853764534e-04 -396644929e-04 229180398e-04]]]]

tensor_name: InceptionResnetV1/Repeat_2/block8_5/Conv2d_1x1/weights

[[[[ 668217181e-05 -105819281e-03 153191842e-03 ,

-311199180e-03 635368563e-03 -274126395e-03]

[ 318233576e-03 -254229619e-03 249305228e-03 ,

330329197e-03 381108536e-03 -274854340e-03]

[ -412645866e-04 619026460e-03 -393131655e-03 ,

264261011e-03 696232868e-03 -355296396e-03]

,

[ -193279085e-03 -377224735e-03 110784564e-02 ,

-516240194e-04 775920600e-03 166762003e-03]

[ 596936443e-04 648493413e-03 -803424604e-03 ,

-460842717e-03 -111874444e-02 -132859335e-03]

[ -108386659e-04 -275659049e-03 142360469e-02 ,

-361400493e-03 932079554e-03 515071768e-03]]]]

开始使用

TensorFlow并不是一个纯粹的神经网络框架, 而是使用数据流图进行数值分析的框架

TensorFlow使用有向图(graph)表示一个计算任务图的节点称为ops(operations)表示对数据的处理,图的边flow 描述数据的流向

该框架计算过程就是处理tensor组成的流 这也是TensorFlow名称的来源

TensorFlow使用tensor表示数据 tensor意为张量即高维数组,在python中使用numpyndarray表示

TensorFlow使用Session执行图, 使用Variable维护状态tfconstant是只能输出的ops, 常用作数据源

下面我们构建一个只有两个constant做输入, 然后进行矩阵乘的简单图:

from tensorflow import Session, device, constant, matmul'''构建一个只有两个constant做输入, 然后进行矩阵乘的简单图:'''#如果不使用with session()语句, 需要手动执行sessionclose()

#with device设备指定了执行计算的设备:

#    "/cpu:0": 机器的 CPU

#    "/gpu:0": 机器的第一个 GPU, 如果有的话

#    "/gpu:1": 机器的第二个 GPU, 以此类推

with Session() as session:  # 创建执行图的上下文

with device('/cpu:0'):  # 指定运算设备

mat1 = constant([[3, 3]])  # 创建源节点

mat2 = constant([[2], [2]])

product = matmul(mat1, mat2) # 指定节点的前置节点, 创建图

result = sessionrun(product) # 执行计算        print(result)123456789101112131415161718

下面使用Variable做一个计数器:

from tensorflow import Session, constant, Variable, add, assign, initialize_all_variables

state = Variable(0, name='counter') # 创建计数器one = constant(1) # 创建数据源: 1val = add(state, one) # 创建新值节点update = assign(state, val) # 更新计数器setup = initialize_all_variables() # 初始化Variablewith Session() as session:

sessionrun(setup) # 执行初始化

print(sessionrun(state)) # 输出初值

for i in range(3):

sessionrun(update) # 执行更新

print(sessionrun(state)) # 输出计数器值12345678910111213

 

在使用变量前必须运行initialize_all_variables()返回的图, 运行Variable节点将返回变量的值

本示例中将构建图的过程写在了上下文之外, 而且没有指定运行设备

上面示例中sessionrun只接受一个op作为参数, 实际上run可以接受op列表作为输入:

sessionrun([op1, op2])1

上述示例一直使用constant作为数据源, feed可以在运行时动态地输入数据:

from tensorflow import Session, placeholder, mul, float32

input1 = placeholder(float32)

input2 = placeholder(float32)

output = mul(input1, input2)with Session() as session:    print sessionrun(output, feed_dict={input1: [3], input2: [2]})1234567

实现一个简单神经网络

神经网络是应用广泛的机器学习模型, 关于神经网络的原理可以参见这篇随笔, 或者在tensorflow playground上体验一下在线demo

首先定义一个BPNeuralNetwork类:

class BPNeuralNetwork:

def __init__(self):

selfsession = tfSession()

selfinput_layer = None

selflabel_layer = None

selfloss = None

selftrainer = None

selflayers = []    def __del__(self):

selfsessionclose()1234567891011

编写一个生成单层神经网络函数,每层神经元用一个数据流图表示使用一个Variable矩阵表示与前置神经元的连接权重, 另一个Variable向量表示偏置值, 并为该层设置一个激励函数

def make_layer(inputs, in_size, out_size, activate=None):

weights = tfVariable(tfrandom_normal([in_size, out_size]))

basis = tfVariable(tfzeros([1, out_size]) + 01)

result = tfmatmul(inputs, weights) + basis    if activate is None:        return result    else:        return activate(result)12345678

使用placeholder作为输入层

selfinput_layer = tfplaceholder(tffloat32, [None, 2])1

placeholder的第二个参数为张量的形状, [None, 1]表示行数不限, 列数为1的二维数组, 含义与numpyarrayshape相同这里, selfinput_layer被定义为接受二维输入的输入层

同样使用placeholder表示训练数据的标签:

selflabel_layer = tfplaceholder(tffloat32, [None, 1])1

使用make_layer为神经网络定义两个隐含层, 并用最后一层作为输出层:

selfloss = tfreduce_mean(tfreduce_sum(tfsquare((selflabel_layer - selflayers[1])), reduction_indices=[1]))1

tftrain提供了一些优化器, 可以用来训练神经网络以损失函数最小化为目标:

selftrainer = tftrainGradientDescentOptimizer(learn_rate)minimize(selfloss)1

使用Session运行神经网络模型:

initer = tfinitialize_all_variables()# do trainingselfsessionrun(initer)

for i in range(limit):

selfsessionrun(selftrainer, feed_dict={selfinput_layer: cases, selflabel_layer: labels})12345

使用训练好的模型进行预测:

selfsessionrun(selflayers[-1], feed_dict={selfinput_layer: case})1

完整代码:

import tensorflow as tfimport numpy as npdef make_layer(inputs, in_size, out_size, activate=None):

weights = tfVariable(tfrandom_normal([in_size, out_size]))

basis = tfVariable(tfzeros([1, out_size]) + 01)

result = tfmatmul(inputs, weights) + basis    if activate is None:        return result    else:        return activate(result)class BPNeuralNetwork:

def __init__(self):

selfsession = tfSession()

selfinput_layer = None

selflabel_layer = None

selfloss = None

selfoptimizer = None

selflayers = []    def __del__(self):

selfsessionclose()    def train(self, cases, labels, limit=100, learn_rate=005):

# 构建网络

selfinput_layer = tfplaceholder(tffloat32, [None, 2])

selflabel_layer = tfplaceholder(tffloat32, [None, 1])

selflayersappend(make_layer(selfinput_layer, 2, 10, activate=tfnnrelu))

selflayersappend(make_layer(selflayers[0], 10, 2, activate=None))

selfloss = tfreduce_mean(tfreduce_sum(tfsquare((selflabel_layer - selflayers[1])), reduction_indices=[1]))

selfoptimizer = tftrainGradientDescentOptimizer(learn_rate)minimize(selfloss)

initer = tfinitialize_all_variables()        # 做训练

selfsessionrun(initer)        for i in range(limit):

selfsessionrun(selfoptimizer, feed_dict={selfinput_layer: cases, selflabel_layer: labels})    def predict(self, case):

return selfsessionrun(selflayers[-1], feed_dict={selfinput_layer: case})    def test(self):

x_data = nparray([[0, 0], [0, 1], [1, 0], [1, 1]])

y_data = nparray([[0, 1, 1, 0]])transpose()

test_data = nparray([[0, 1]])

selftrain(x_data, y_data)

print(selfpredict(test_data))

nn = BPNeuralNetwork()

nntest()12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152

上述模型虽然简单但是使用不灵活, 作者采用同样的思想实现了一个可以自定义输入输出维数以及多层隐含神经元的网络, 可以参见dynamic_bpnnpy

import tensorflow as tfimport numpy as npdef make_layer(inputs, in_size, out_size, activate=None):

weights = tfVariable(tfrandom_normal([in_size, out_size]))

basis = tfVariable(tfzeros([1, out_size]) + 01)

result = tfmatmul(inputs, weights) + basis    if activate is None:        return result    else:        return activate(result)class BPNeuralNetwork:

def __init__(self):

selfsession = tfSession()

selfloss = None

selfoptimizer = None

selfinput_n = 0

selfhidden_n = 0

selfhidden_size = []

selfoutput_n = 0

selfinput_layer = None

selfhidden_layers = []

selfoutput_layer = None

selflabel_layer = None

def __del__(self):

selfsessionclose()    def setup(self, ni, nh, no):

# 设置参数个数

selfinput_n = ni

selfhidden_n = len(nh)  #隐藏层的数量

selfhidden_size = nh  #每个隐藏层中的单元格数

selfoutput_n = no        #构建输入层

selfinput_layer = tfplaceholder(tffloat32, [None, selfinput_n])        #构建标签层

selflabel_layer = tfplaceholder(tffloat32, [None, selfoutput_n])        #构建隐藏层

in_size = selfinput_n

out_size = selfhidden_size[0]

inputs = selfinput_layer

selfhidden_layersappend(make_layer(inputs, in_size, out_size, activate=tfnnrelu))        for i in range(selfhidden_n-1):

in_size = out_size

out_size = selfhidden_size[i+1]

inputs = selfhidden_layers[-1]

selfhidden_layersappend(make_layer(inputs, in_size, out_size, activate=tfnnrelu))        #构建输出层

selfoutput_layer = make_layer(selfhidden_layers[-1], selfhidden_size[-1], selfoutput_n)    def train(self, cases, labels, limit=100, learn_rate=005):

selfloss = tfreduce_mean(tfreduce_sum(tfsquare((selflabel_layer - selfoutput_layer)), reduction_indices=[1]))

selfoptimizer = tftrainGradientDescentOptimizer(learn_rate)minimize(selfloss)

initer = tfinitialize_all_variables()        #做训练

selfsessionrun(initer)        for i in range(limit):

selfsessionrun(selfoptimizer, feed_dict={selfinput_layer: cases, selflabel_layer: labels})    def predict(self, case):

return selfsessionrun(selfoutput_layer, feed_dict={selfinput_layer: case})    def test(self):

x_data = nparray([[0, 0], [0, 1], [1, 0], [1, 1]])

y_data = nparray([[0, 1, 1, 0]])transpose()

test_data = nparray([[0, 1]])

selfsetup(2, [10, 5], 1)

selftrain(x_data, y_data)

print(selfpredict(test_data))

nn = BPNeuralNetwork()

nntest()12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576

打开终端

运行下面的命令来启用TensorFlow source activate tensorflow

现在我们已经进入了TensorFlow的环境，我们要在这个环境中安装iPython和jupyter，运行下面的命令conda install ipython以及conda install jupyter

下面的步骤基本上按照Using a virtualenv in an IPython notebook中的进行，只是多加了一点内容。首先运行下面的命令，ipython kernelspec install-self --user,我这里得到的结果是Installed kernelspec python3 in /Users/charliebrummitt/Library/Jupyter/kernels/python3

运行下边的命令mkdir -p ~/ipython/kernels 

然后运行下边的命令，使用你选择的名字来代替<kernel_name>（我使用的tfkernel），并且使用第4步中得到的路径(例如，~/local/share/jupyter/kernels/pythonX)来替换下方命令中的第一个路径。mv ~/local/share/jupyter/kernels/pythonX ~/ipython/kernels/<kernel_name>

现在，打开Jupyter Notebook，选择Kernel -> Change kernel，你将看到一个新的kernel。但是，新的kernel与你之前的kernel拥有相同点名字，运行下边的命令，给你的新kernel起一个不同的名字。cd ~/ipython/kernels/tfkernel/。接着，运行vim kerneljson来编辑kerneljson文件，将"display_name"中的默认值Python 3替换为你的新名字，然后保存，并退出。

打开一个新的Jupyter Notebook，输入一行import tensorflow as tf并运行，如果没有出现任何错误，那么就搞定了。

正态分布（Normal distribution），也称“常态分布”，又名高斯分布（Gaussian distribution）。

正态曲线呈钟型，两头低，中间高，左右对称因其曲线呈钟形，因此人们又经常称之为钟形曲线。

在TF中会大量使用到正态分布，熟练的使用它，也是使用TF的基本功之一。下面来看一下在Python中如何使用。

用numpy来获取一个标准正态分布的样例

一维正太分布如上面定义所说，正如一个“钟形”

或者如下两者

和

效果都如之前的

mu控制函数中心位置左右移动，如下mu=6的场景

sigma=10的场景

记住这个特性，在获取一维正太分布数据时很有帮助。

二维正太分布的公式如下，

二维正太分布使用不一样的numpy函数， multivariate_normal

二维标准正太分布如下，不在是一个“钟”，而像一个“圆”

这里的参数也有变化。

mean表示二维数组每一维的均值；是一个（1，2）矩阵。

cov表示二维数组的 协方差 ；是一个（2，2）矩阵。

可以看出来mean是圆的圆点，那么是不是改变了mean，圆就会发生移动呢？ 我们试一下。

那么cov 协方差代表的意义 也通过实验来看一下，

用TensorFlow训练网络时，经常需要初始化指定内容的矩阵，所以这里把常用的初始化方法总结出来。其它平台例如Caffe、PyTorch都能用到这里的思想，方法都是类似的，还有常用的numpy库也是一样的，重要的是理解。

生成指定 shape 的矩阵，并且所有元素设置为 1 ， dtype 为元素类型， name 为 *** 作名

和 tfones 方法类似，区别是这里元素的值为0

生成和 tensor 同样纬度的矩阵，里面所有元素的值为1

生成和 tensor 同样纬度的矩阵，里面所有元素的值为0

生成指定 dims 的矩阵，里面所有元素的值为 value

生成指定 shape 的矩阵，里面所有元素的值为 value

生成指定 shape 的矩阵，里面元素的值根据 正太分布 随机生成，均值为 mean ，标准差为 stddev

和 tfrandom_normal 类似，不过只保留 [mean-2×stddev,mean+2×stddev] 范围内的随机数( 截断正太分布 )

生成指定 shape 的矩阵，里面元素的值根据 均匀分布 随机生成，最小值为 minval ，最大值为 maxval

生成等差数列，起始值为 start ,结束值为 stop ，共取 num 个值，虽然不是矩阵，但是我们可以通过 reshape 转换成矩阵

生成等差数列，起始值为 start ,结束值为 stop ，以间隔 delta 取值，虽然不是矩阵，但是我们可以通过 reshape 转换成矩阵

以上就是关于Tensorflow——关于loss全部的内容，包括:Tensorflow——关于loss、JIT（上）：Tensorflow如何实现即时编译、统一 MXNet & PyTorch & TensorFlow 部分基础运算等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！