精华内容
下载资源
问答
  • 今天小编就为大家分享一篇Pytorch中的自动求梯度机制和Variable类实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 为什么需要Variable Variables是Tkinter编程中非常重要的组成部分。它存在的目的是为了解决Python中存在的一个“问题”,即Python本身并不支持变量回溯。 而变量的回溯在GUI编程中是极为重要的部分。考虑如下的场景...

    为什么需要Variable

    • Variables是Tkinter编程中非常重要的组成部分。它存在的目的是为了解决Python中存在的一个“问题”,即Python本身并不支持变量回溯。
    • 而变量的回溯在GUI编程中是极为重要的部分。考虑如下的场景:在你的GUI界面中有一个Entry输入框和一个按钮,每当用户按下按钮时都会将输入框中的值通过messagebox.showinfo消息框显示出来
      from tkinter import Tk, Variable, Entry, Button
      from tkinter.messagebox import showinfo
      tk = Tk()
      a = Variable(tk, value='123')
      e = Entry(tk, textvariable=a)
      b = Button(tk, command=lambda *args: showinfo(message=a.get()),
                text="GET")
      e.pack()
      b.pack()
      tk.mainloop()
      
      效果如下:

      通过Variable作为前段和后端的桥梁,我们便可以很方便的获取用户输入的值。

    Variable常用的使用方法

    • 根据所包装的变量的不同,共有如下的四种Variable: BooleanVar, DoubleVar, IntVar, StringVar, 除了类型不同, 其使用方法完全一致

    实例化一个Variable对象

    • 例: 实例化一个StringVar
      var = StringVar()
      
      可以通过value属性为其赋初值

    对一个Variable对象进行读取or写入操作

    • 通过Variable对象的setget方法进行
    • set
      from tkinter import *
      tk = Tk()
      v = Variable()
      v.set("123")
      e = Entry(tk, textvariable=v)
      e.pack()
      tk.mainloop()
      
    • get
      (可以参考例1)

    Variable对象执行读or写or销毁操作本身也可以触发事件

    • 调用Variabletrace方法,在Variable的值被读取or写入or销毁的时候触发事件,进而调用回调函数。
    • trace方法接收两个参数: mode指定了事件的类型, 用"r"表示读取操作, 用"w"表示写入操作, 用"u"表示销毁操作. callback指定了当mode中指定的事件触发时调用的回调函数
    • 例: 当对一个Entry执行写入操作时, 触发回调函数:
      from tkinter import *
      from tkinter.messagebox import *
      
      def callback(*args):
          showinfo(message="I've been changed")
      tk = Tk()
      v = Variable()
      v.trace("w", callback)
      e = Entry(tk, textvariable=v)
      e.pack()
      tk.mainloop()
      
      执行后,每当改变Entry中的值,都会有提示框出现。

    获取更多对Variable的介绍,建议参考官方文档:https://effbot.org/tkinterbook/variable.htm
    欢迎关注我的微信公众号: Code Segment, 获取更多关于编程等内容的文章。

    展开全文
  • Pytorch之Variable的用法

    2020-09-18 04:43:36
    今天小编就为大家分享一篇Pytorch之Variable的用法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • [Tkinter 教程04] Variable

    千次阅读 2017-03-07 00:43:32
    Variable 有些控件 (比如 Entry 控件, Radiobutton 控件 等) 可以通过传入特定参数直接和一个程序变量绑定, 这些参数包括: variable, textvariable, onvalue, offvalue, value. 这种绑定是双向的: 如果该变量发生...

    原系列地址: Python Tkinter

    Variable 类

    有些控件 (比如 Entry 控件, Radiobutton 控件 等) 可以通过传入特定参数直接和一个程序变量绑定, 这些参数包括: variable, textvariable, onvalue, offvalue, value. 这种绑定是双向的: 如果该变量发生改变, 与该变量绑定的控件也会随之更新. 这些 Tkinter 控制变量和一般的 Python 变量一样, 都是用来保存某个值的. 但一般的 Python 变量不能被传递给 variable 或者 textvariable 参数. 这些参数可接受的类型仅限于 Tkinter 包中的 Variable 类的子类. 如下:

    • x = StringVar() # 保存一个 string 类型变量, 默认值为""
    • x = IntVar() # 保存一个整型变量, 默认值为0
    • x = DoubleVar() # 保存一个浮点型变量, 默认值为0.0
    • x = BooleanVar() # 保存一个布尔型变量, 返回值为 0 (代表 False) 或 1 (代表 True)

    要得到其保存的变量值, 使用它的 get() 方法即可.
    要设置其保存的变量值, 使用它的 set() 方法即可.


    译者水平有限, 如有疏漏, 欢迎指正.
    已获得原作者授权. 原文地址: Variable Classes

    展开全文
  • torch.autograd.backward...当前Variable对leaf variable求偏导。 计算图可以通过链式法则求导。如果Variable是 非标量(non-scalar)的,且requires_grad=True。那么此函数需要指定gradient,它的形状应该和Variab...

    torch.autograd.backward(variables, grad_variables, retain_variables=False)

    当前Variable对leaf variable求偏导。

    计算图可以通过链式法则求导。如果Variable是 非标量(non-scalar)的,且requires_grad=True。那么此函数需要指定gradient,它的形状应该和Variable的长度匹配,里面保存了Variable的梯度。

    此函数累积leaf variable的梯度。你可能需要在调用此函数之前将Variable的梯度置零。

    参数说明:

    • variables (variable 列表) – 被求微分的叶子节点,即 ys

    • grad_variables (Tensor 列表) – 对应variable的梯度。仅当variable不是标量且需要求梯度的时候使用。见下例中的c.backward(torch.ones(a.size()))

    • retain_variables (bool) – True,计算梯度时所需要的buffer在计算完梯度后不会被释放。如果想对一个子图多次求微分的话,需要设置为True

    # retain_variables用法

    x = V(t.ones(3))

    w = V(t.rand(3),requires_grad=True)

    y = w.mul(x)

    z = y.sum()

    z.backward(retain_graph=True)

    print(w.grad)

    z.backward()#保留了上一次的结果,才能再一次backward()否则图也解散第二次backward()会报错:Trying to backward through the graph a second time, but the buffers have already been freed. Specify retain_graph=True when calling backward the first time 当然你也可以选择再构造一次图 y = w.mul(x)  z = y.sum()然后再backward()也可以

    print(w.grad)

    Variable containing:
     1
     1
     1
    
    Variable containing:【第二次结果是进行了累加第一次】
     2
     2
     2
    

    在PyTorch中计算图的特点可总结如下:


    叶子节点对象【用户自己创造的对象】是一个 AccumulateGrad Object 表示梯度累加对象。通过grad_fn.next_functions可得。
                                                     非叶子节点的梯度计算完之后即被清空,grad为None 用 retain_grad可保留中间梯度

     

     

    a = V(t.ones(3,4),requires_grad=True)        叶子节点 grad_fn为None       backward后grad

    b = V(t.zeros(3,4))requires_grad=False        叶子节点 grad_fn为None       backward后grad无

    c = a.add(b) 所有依赖a的节点requires_grad=True  grad_fn为AddBackward1   backward后grad无

    d = c.sum()   所有依赖a的节点 requires_grad=True  grad_fnsumBackward1   backward后grad无


    d.backward()  这时候d是标量12,所以可以省略backward的grad_variable参数,默认(torch.FloatTensor([1]))

    c.backward(torch.ones(a.size())) c 是向量,需定义backward的grad_variable参数,表示每一个都是1倍梯度。


     

    • autograd根据用户对variable的操作Function构建其计算图。对变量的操作抽象为Function
    • 对于那些不是任何函数(Function)的输出,由用户创建的节点称为叶子节点,叶子节点的grad_fn为None。叶子节点中需要求导的variable,具有AccumulateGrad标识,因其梯度是累加的。
    • variable默认是不需要求导的,即requires_grad属性默认为False,如果某一个节点requires_grad被设置为True,那么所有依赖它的节点requires_grad都为True。
    • variable的volatile属性默认为False,如果某一个variable的volatile属性被设为True,那么所有依赖它的节点volatile属性都为True。volatile属性为True的节点不会求导,volatile的优先级比requires_grad高。已经被torch.no_grad()替代
    • 多次反向传播时,梯度是累加的。反向传播的中间缓存会被清空,为进行多次反向传播需指定retain_graph=True来保存这些缓存。
    • 非叶子节点的梯度计算完之后即被清空,可以使用autograd.gradhook技术获取非叶子节点的值。
    • variable的grad与data形状一致,应避免直接修改variable.data,因为对data的直接操作无法利用autograd进行反向传播
    • 反向传播函数backward的参数grad_variables可以看成链式求导的中间结果,如果是标量,可以省略,默认为1
    • PyTorch采用动态图设计,可以很方便地查看中间层的输出,动态的设计计算图结构。

     

    Variable类和计算图

    简单的建立一个计算图,便于理解几个相关知识点:

    • requires_grad  是否要求导数,默认False,叶节点指定True后,依赖节点都被置为True

    • .backward()  根Variable的方法会反向求解叶Variable的梯度

    • .backward()方法grad_variable参数  形状与根Variable一致,非标量Variable反向传播方向指定

    • 叶节点  由用户创建的计算图Variable对象,反向传播后会保留梯度grad数值,非叶子节点Variable会清空为None

    • grad_fn  指向创建Tensor的Function,如果某一个对象由用户创建叶子节点,则指向None

    •  .is_leaf  是否是叶节点

    • .grad_fn.next_functions  本节点接收的上级节点的grad_fn,# grad_fn.next_functions代表了本节点的输入节点信息grad_fn表示了本节点的输出信息

    • .volatile  是否处于推理模式 作用于依赖路径全部的Variable。已经被torch.no_grad(), torch.set_grad_enabled(grad_mode)替代,在0.4版本中。【具体案例见下面volatile部分】

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    import torch as t

    from torch.autograd import Variable as V

     

    a = V(t.ones(3,4),requires_grad=True)

    b = V(t.zeros(3,4))

    c = a.add(b)

    d = c.sum()

    d.backward()

     

    # 虽然没有要求cd的梯度,但是cd依赖于a,所以a要求求导则cd梯度属性会被默认置为True

    print(a.requires_grad, b.requires_grad, c.requires_grad,d.requires_grad)

    # 叶节点(由用户创建)的grad_fn指向None

    print(a.is_leaf, b.is_leaf, c.is_leaf,d.is_leaf)

    # 中间节点虽然要求求梯度,但是由于不是叶节点,其梯度不会保留,所以仍然是None

    print(a.grad,b.grad,c.grad,d.grad)

    True False True True
    True True False False
    Variable containing:
     1  1  1  1
     1  1  1  1
     1  1  1  1
    [torch.FloatTensor of size 3x4]
     None None None

    1

    print('\n',a.grad_fn,'\n',b.grad_fn,'\n',c.grad_fn,'\n',d.grad_fn)

    None 
    None 
    <AddBackward1 object at 0x000002A2F3D2EBA8> 
    <SumBackward0 object at 0x000002A2F3D2ECC0>
    

     

    .grad_fn.next_functions

    # grad_fn.next_functions代表了本节点的输入节点信息,grad_fn表示了本节点的输出信息

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    x = V(t.ones(1))

    w = V(t.rand(1),requires_grad=True)

    b = V(t.rand(1),requires_grad=True)

     

    y = w.mul(x)   #((<AccumulateGrad object at 0x000002A2F57F5630>, 0), (None, 0)) :(w,x)

    z = y.add(b)  #((<MulBackward1 object at 0x000002A2F57F57B8>, 0), (<AccumulateGrad object at 0x000002A2F57F57F0>, 0)) : (y,b)

     

    print(x.is_leaf,w.is_leaf,b.is_leaf,y.is_leaf,z.is_leaf)

    print(x.requires_grad,w.requires_grad,b.requires_grad,y.requires_grad,z.requires_grad)

    print(x.grad_fn,w.grad_fn,b.grad_fn,y.grad_fn,z.grad_fn)

     

    # grad_fn.next_functions

    # grad_fn.next_functions代表了本节点的输入节点信息,grad_fn表示了本节点的输出信息

    # 叶子结点grad_fn为None,没有next_functions,但是间接查询到AccumulateGrad object表示该叶子节点

    # 接受梯度更新,查询到None表示不接受更新

    print(y.grad_fn.next_functions,z.grad_fn.next_functions)

    print(z.grad_fn.next_functions[0][0]==y.grad_fn)

    print(z.grad_fn.next_functions[0][0],y.grad_fn)

    .is_leaf
    True True True False False
    
    .requires_grad
    False True True True True
    
    .grad_fn
    None None None <MulBackward1 object at 0x000002A2F57F5710> <AddBackward1 object at 0x000002A2F57F5630>
    
    .grad_fn.next_functions
    ((<AccumulateGrad object at 0x000002A2F57F5630>, 0), (None, 0))第一个参数是w,用户自己创造的叶子节点,梯度累加行AccumulateGrad,第二是x 
    ((<MulBackward1 object at 0x000002A2F57F57B8>, 0), 
    (<AccumulateGrad object at 0x000002A2F57F57F0>, 0))
    z.grad_fn.next_functions[0][0]==y.grad_fn
    True 
    z.grad_fn.next_functions[0][0],y.grad_fn
    <MulBackward1 object at 0x000002A2F57F57F0> <MulBackward1 object at 0x000002A2F57F57F0>

    .volatile

    volatile was removed and now has no effect. Use `with torch.no_grad():` instead

     

    1

    2

    3

    4

    5

    6

    7

    8

    9

    # volatile

    # 节省显存提高效用的参数volatile,也会作用于依赖路径全部的Variable上,且优先级高于requires_grad,

    # 这样我们在实际设计网络时不必修改其他叶子结点的requires_grad属性,只要将输入叶子volatile=True即可

     

    x = V(t.ones(1),volatile=True)

    w = V(t.rand(1),requires_grad=True)

    y = w.mul(x)

    print(x.requires_grad,w.requires_grad,y.requires_grad)

    print(x.volatile,w.volatile,y.volatile)

    False True False 
    True False True

    .volatile已经被orch.no_grad(), torch.set_grad_enabled(grad_mode)替代,在0.4版本中。

    >>> x = torch.zeros(1, requires_grad=True)
    >>> with torch.no_grad():
    ...     y = x * 2
    >>> y.requires_grad
    False
    >>>
    >>> is_train = False
    >>> with torch.set_grad_enabled(is_train):
    ...     y = x * 2#这样形成的y不求导
    >>> y.requires_grad
    False
    >>> torch.set_grad_enabled(True)  # this can also be used as a function
    >>> y = x * 2
    >>> y.requires_grad
    True
    >>> torch.set_grad_enabled(False)
    >>> y = x * 2
    >>> y.requires_grad
    False

    附录、Variable类源码简介

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    56

    57

    58

    59

    60

    61

    62

    63

    64

    65

    66

    67

    68

    69

    70

    71

    72

    73

    74

    75

    76

    77

    78

    79

    80

    81

    82

    83

    84

    85

    86

    87

    88

    89

    90

    91

    92

    93

    94

    95

    96

    97

    98

    99

    100

    101

    102

    103

    104

    105

    106

    107

    108

    109

    110

    111

    112

    113

    114

    115

    116

    117

    118

    class Variable(_C._VariableBase):

     

        """

        Attributes:

            data: 任意类型的封装好的张量。

            grad: 保存与data类型和位置相匹配的梯度,此属性难以分配并且不能重新分配。

            requires_grad: 标记变量是否已经由一个需要调用到此变量的子图创建的bool值。只能在叶子变量上进行修改。

            volatile: 标记变量是否能在推理模式下应用(如不保存历史记录)的bool值。只能在叶变量上更改。

            is_leaf: 标记变量是否是图叶子(如由用户创建的变量)的bool值.

            grad_fn: Gradient function graph trace.

     

        Parameters:

            data (any tensor class): 要包装的张量.

            requires_grad (bool): bool型的标记值. **Keyword only.**

            volatile (bool): bool型的标记值. **Keyword only.**

        """

     

        def backward(self, gradient=None, retain_graph=None, create_graph=None, retain_variables=None):

            """计算关于当前图叶子变量的梯度,图使用链式法则导致分化

            如果Variable是一个标量(例如它包含一个单元素数据),你无需对backward()指定任何参数

            如果变量不是标量(包含多个元素数据的矢量)且需要梯度,函数需要额外的梯度;

            需要指定一个和tensor的形状匹配的grad_output参数(y在指定方向投影对x的导数);

            可以是一个类型和位置相匹配且包含与自身相关的不同函数梯度的张量。

            函数在叶子上累积梯度,调用前需要对该叶子进行清零。

     

            Arguments:

                grad_variables (Tensor, Variable or None):

                               变量的梯度,如果是一个张量,除非“create_graph”是True,否则会自动转换成volatile型的变量。

                               可以为标量变量或不需要grad的值指定None值。如果None值可接受,则此参数可选。

                retain_graph (bool, optional): 如果为False,用来计算梯度的图将被释放。

                                               在几乎所有情况下,将此选项设置为True不是必需的,通常可以以更有效的方式解决。

                                               默认值为create_graph的值。

                create_graph (bool, optional): 为True时,会构造一个导数的图,用来计算出更高阶导数结果。

                                               默认为False,除非``gradient``是一个volatile变量。

            """

            torch.autograd.backward(self, gradient, retain_graph, create_graph, retain_variables)

     

     

        def register_hook(self, hook):

            """Registers a backward hook.

     

            每当与variable相关的梯度被计算时调用hook,hook的申明:hook(grad)->Variable or None

            不能对hook的参数进行修改,但可以选择性地返回一个新的梯度以用在`grad`的相应位置。

     

            函数返回一个handle,其``handle.remove()``方法用于将hook从模块中移除。

     

            Example:

                >>> v = Variable(torch.Tensor([0, 0, 0]), requires_grad=True)

                >>> h = v.register_hook(lambda grad: grad * 2)  # double the gradient

                >>> v.backward(torch.Tensor([1, 1, 1]))

                >>> v.grad.data

                 2

                 2

                 2

                [torch.FloatTensor of size 3]

                >>> h.remove()  # removes the hook

            """

            if self.volatile:

                raise RuntimeError("cannot register a hook on a volatile variable")

            if not self.requires_grad:

                raise RuntimeError("cannot register a hook on a variable that "

                                   "doesn't require gradient")

            if self._backward_hooks is None:

                self._backward_hooks = OrderedDict()

                if self.grad_fn is not None:

                    self.grad_fn._register_hook_dict(self)

            handle = hooks.RemovableHandle(self._backward_hooks)

            self._backward_hooks[handle.id] = hook

            return handle

     

        def reinforce(self, reward):

            """Registers a reward obtained as a result of a stochastic process.

            区分随机节点需要为他们提供reward值。如果图表中包含任何的随机操作,都应该在其输出上调用此函数,否则会出现错误。

            Parameters:

                reward(Tensor): 带有每个元素奖赏的张量,必须与Variable数据的设备位置和形状相匹配。

            """

            if not isinstance(self.grad_fn, StochasticFunction):

                raise RuntimeError("reinforce() can be only called on outputs "

                                   "of stochastic functions")

            self.grad_fn._reinforce(reward)

     

        def detach(self):

            """返回一个从当前图分离出来的新变量。

            结果不需要梯度,如果输入是volatile,则输出也是volatile。

     

            .. 注意::

              返回变量使用与原始变量相同的数据张量,并且可以看到其中任何一个的就地修改,并且可能会触发正确性检查中的错误。

            """

            result = NoGrad()(self# this is needed, because it merges version counters

            result._grad_fn = None

            return result

     

        def detach_(self):

            """从创建它的图中分离出变量并作为该图的一个叶子"""

            self._grad_fn = None

            self.requires_grad = False

     

        def retain_grad(self):

            """Enables .grad attribute for non-leaf Variables."""

            if self.grad_fn is None# no-op for leaves

                return

            if not self.requires_grad:

                raise RuntimeError("can't retain_grad on Variable that has requires_grad=False")

            if hasattr(self, 'retains_grad'):

                return

            weak_self = weakref.ref(self)

     

            def retain_grad_hook(grad):

                var = weak_self()

                if var is None:

                    return

                if var._grad is None:

                    var._grad = grad.clone()

                else:

                    var._grad = var._grad + grad

     

            self.register_hook(retain_grad_hook)

            self.retains_grad = True

    展开全文
  • 相关的包括std::condition_variable和std::condition_variable_any,还有枚举类型std::cv_status。另外还包括函数std::notify_all_at_thread_exit(),下面分别介绍一下以上几种类型。 std::condition_variable ...

    总结的很详细,打算记录下来。

    原文地址:https://www.2cto.com/kf/201506/411327.html

    头文件主要包含了与条件变量相关的类和函数。相关的类包括 std::condition_variable和 std::condition_variable_any,还有枚举类型std::cv_status。另外还包括函数 std::notify_all_at_thread_exit(),下面分别介绍一下以上几种类型。

    std::condition_variable 类介绍

    std::condition_variable是条件变量,更多有关条件变量的定义参考维基百科。Linux下使用 Pthread库中的 pthread_cond_*() 函数提供了与条件变量相关的功能, Windows 则参考 MSDN

    当 std::condition_variable对象的某个wait 函数被调用的时候,它使用 std::unique_lock(通过 std::mutex) 来锁住当前线程。当前线程会一直被阻塞,直到另外一个线程在相同的 std::condition_variable 对象上调用了 notification 函数来唤醒当前线程。

    std::condition_variable 对象通常使用 std::unique_lock 来等待,如果需要使用另外的 lockable 类型,可以使用std::condition_variable_any类,本文后面会讲到 std::condition_variable_any 的用法。

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    <code class="hljs cpp">#include <iostream>                // std::cout

    #include <thread>                // std::thread

    #include <mutex>                // std::mutex, std::unique_lock

    #include <condition_variable>    // std::condition_variable

     

    std::mutex mtx; // 全局互斥锁.

    std::condition_variable cv; // 全局条件变量.

    bool ready = false// 全局标志位.

     

    void do_print_id(int id)

    {

        std::unique_lock <std::mutex> lck(mtx);

        while (!ready) // 如果标志位不为 true, 则等待...

            cv.wait(lck); // 当前线程被阻塞, 当全局标志位变为 true 之后,

        // 线程被唤醒, 继续往下执行打印线程编号id.

        std::cout << "thread " << id << '\n';

    }

     

    void go()

    {

        std::unique_lock <std::mutex> lck(mtx);

        ready = true// 设置全局标志位为 true.

        cv.notify_all(); // 唤醒所有线程.

    }

     

    int main()

    {

        std::thread threads[10];

        // spawn 10 threads:

        for (int i = 0; i < 10; ++i)

            threads[i] = std::thread(do_print_id, i);

     

        std::cout << "10 threads ready to race...\n";

        go(); // go!

     

      for (auto & th:threads)

            th.join();

     

        return 0;

    }</std::mutex></std::mutex></condition_variable></mutex></thread></iostream></code>

    结果:

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    <code class="hljs lasso">10 threads ready to race...

    thread 1

    thread 0

    thread 2

    thread 3

    thread 4

    thread 5

    thread 6

    thread 7

    thread 8

    thread 9</code>

    好了,对条件变量有了一个基本的了解之后,我们来看看 std::condition_variable 的各个成员函数。

    std::condition_variable 的拷贝构造函数被禁用,只提供了默认构造函数。

    std::condition_variable::wait() 介绍:

    ?

    1

    2

    3

    4

    5

    <code class="hljs d">void wait (unique_lock<mutex>& lck);

     

     

    template <class predicate="">

      void wait (unique_lock<mutex>& lck, Predicate pred);</mutex></class></mutex></code>

    std::condition_variable提供了两种 wait() 函数。当前线程调用 wait() 后将被阻塞(此时当前线程应该获得了锁(mutex),不妨设获得锁 lck),直到另外某个线程调用 notify_* 唤醒了当前线程。

    在线程被阻塞时,该函数会自动调用 lck.unlock() 释放锁,使得其他被阻塞在锁竞争上的线程得以继续执行。另外,一旦当前线程获得通知(notified,通常是另外某个线程调用 notify_* 唤醒了当前线程),wait()函数也是自动调用 lck.lock(),使得lck的状态和 wait 函数被调用时相同。

    在第二种情况下(即设置了 Predicate),只有当 pred 条件为false 时调用 wait() 才会阻塞当前线程,并且在收到其他线程的通知后只有当 pred 为 true 时才会被解除阻塞。因此第二种情况类似以下代码:

    ?

    1

    <code class="hljs perl">while (!pred()) wait(lck);</code>

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    <code class="hljs cpp">#include <iostream>                // std::cout

    #include <thread>                // std::thread, std::this_thread::yield

    #include <mutex>                // std::mutex, std::unique_lock

    #include <condition_variable>    // std::condition_variable

     

    std::mutex mtx;

    std::condition_variable cv;

     

    int cargo = 0;

    bool shipment_available()

    {

        return cargo != 0;

    }

     

    // 消费者线程.

    void consume(int n)

    {

        for (int i = 0; i < n; ++i) {

            std::unique_lock <std::mutex> lck(mtx);

            cv.wait(lck, shipment_available);

            std::cout << cargo << '\n';

            cargo = 0;

        }

    }

     

    int main()

    {

        std::thread consumer_thread(consume, 10); // 消费者线程.

     

        // 主线程为生产者线程, 生产 10 个物品.

        for (int i = 0; i < 10; ++i) {

            while (shipment_available())

                std::this_thread::yield();

            std::unique_lock <std::mutex> lck(mtx);

            cargo = i + 1;

            cv.notify_one();

        }

     

        consumer_thread.join();

     

        return 0;

    }</std::mutex></std::mutex></condition_variable></mutex></thread></iostream></code>

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    <code class="hljs ">1

    2

    3

    4

    5

    6

    7

    8

    9

    10</code>

    std::condition_variable::wait_for() 介绍

    ?

    1

    2

    3

    4

    5

    6

    7

    <code class="hljs ruby">template <class period="">

      cv_status wait_for (unique_lock<mutex>& lck,

                          const chrono::duration<rep,period>& rel_time);

     

    template <class predicate="">

           bool wait_for (unique_lock<mutex>& lck,

                          const chrono::duration<rep,period>& rel_time, Predicate pred);</rep,period></mutex></class></rep,period></mutex></class></code>

    std::condition_variable::wait() 类似,不过 wait_for可以指定一个时间段,在当前线程收到通知或者指定的时间 rel_time 超时之前,该线程都会处于阻塞状态。而一旦超时或者收到了其他线程的通知,wait_for返回,剩下的处理步骤和 wait()类似。

    另外,wait_for 的重载版本的最后一个参数pred表示 wait_for的预测条件,只有当 pred条件为false时调用 wait()才会阻塞当前线程,并且在收到其他线程的通知后只有当 pred为 true时才会被解除阻塞,因此相当于如下代码:

    ?

    1

    <code class="hljs ruby">return wait_until (lck, chrono::steady_clock::now() + rel_time, std::move(pred));</code>

    请看下面的例子(参考),下面的例子中,主线程等待th线程输入一个值,然后将th线程从终端接收的值打印出来,在th线程接受到值之前,主线程一直等待,每个一秒超时一次,并打印一个 "."

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    <code class="hljs cpp">#include <iostream>           // std::cout

    #include <thread>             // std::thread

    #include <chrono>             // std::chrono::seconds

    #include <mutex>              // std::mutex, std::unique_lock

    #include <condition_variable> // std::condition_variable, std::cv_status

     

    std::condition_variable cv;

     

    int value;

     

    void do_read_value()

    {

        std::cin >> value;

        cv.notify_one();

    }

     

    int main ()

    {

        std::cout << "Please, enter an integer (I'll be printing dots): \n";

        std::thread th(do_read_value);

     

        std::mutex mtx;

        std::unique_lock<std::mutex> lck(mtx);

        while (cv.wait_for(lck,std::chrono::seconds(1)) == std::cv_status::timeout) {

            std::cout << '.';

            std::cout.flush();

        }

     

        std::cout << "You entered: " << value << '\n';

     

        th.join();

        return 0;

    }</std::mutex></condition_variable></mutex></chrono></thread></iostream></code>

    std::condition_variable::wait_until 介绍

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    <code class="hljs ruby">template <class duration="">

      cv_status wait_until (unique_lock<mutex>& lck,

                            const chrono::time_point<clock,duration>& abs_time);

     

    template <class predicate="">

           bool wait_until (unique_lock<mutex>& lck,

                            const chrono::time_point<clock,duration>& abs_time,

                            Predicate pred);

    </clock,duration></mutex></class></clock,duration></mutex></class></code>

    与 std::condition_variable::wait_for 类似,但是wait_until可以指定一个时间点,在当前线程收到通知或者指定的时间点 abs_time超时之前,该线程都会处于阻塞状态。而一旦超时或者收到了其他线程的通知,wait_until返回,剩下的处理步骤和 wait_until() 类似。

    另外,wait_until的重载版本的最后一个参数 pred表示 wait_until 的预测条件,只有当 pred条件为 false时调用 wait()才会阻塞当前线程,并且在收到其他线程的通知后只有当pred为 true时才会被解除阻塞,因此相当于如下代码:

    ?

    1

    2

    3

    4

    <code class="hljs ruby">while (!pred())

      if ( wait_until(lck,abs_time) == cv_status::timeout)

        return pred();

    return true;</code>

    std::condition_variable::notify_one() 介绍

    唤醒某个等待(wait)线程。如果当前没有等待线程,则该函数什么也不做,如果同时存在多个等待线程,则唤醒某个线程是不确定的(unspecified)

    请看下例(参考):

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    <code class="hljs cpp">

    #include <iostream>                // std::cout

    #include <thread>                // std::thread

    #include <mutex>                // std::mutex, std::unique_lock

    #include <condition_variable>    // std::condition_variable

     

    std::mutex mtx;

    std::condition_variable cv;

     

    int cargo = 0// shared value by producers and consumers

     

    void consumer()

    {

        std::unique_lock < std::mutex > lck(mtx);

        while (cargo == 0)

            cv.wait(lck);

        std::cout << cargo << '\n';

        cargo = 0;

    }

     

    void producer(int id)

    {

        std::unique_lock < std::mutex > lck(mtx);

        cargo = id;

        cv.notify_one();

    }

     

    int main()

    {

        std::thread consumers[10], producers[10];

     

        // spawn 10 consumers and 10 producers:

        for (int i = 0; i < 10; ++i) {

            consumers[i] = std::thread(consumer);

            producers[i] = std::thread(producer, i + 1);

        }

     

        // join them back:

        for (int i = 0; i < 10; ++i) {

            producers[i].join();

            consumers[i].join();

        }

     

        return 0;

    }</condition_variable></mutex></thread></iostream></code>

    std::condition_variable::notify_all() 介绍

    唤醒所有的等待(wait)线程。如果当前没有等待线程,则该函数什么也不做。请看下面的例子:

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    <code class="hljs cpp">

    #include <iostream>                // std::cout

    #include <thread>                // std::thread

    #include <mutex>                // std::mutex, std::unique_lock

    #include <condition_variable>    // std::condition_variable

     

    std::mutex mtx; // 全局互斥锁.

    std::condition_variable cv; // 全局条件变量.

    bool ready = false// 全局标志位.

     

    void do_print_id(int id)

    {

        std::unique_lock <std::mutex> lck(mtx);

        while (!ready) // 如果标志位不为 true, 则等待...

            cv.wait(lck); // 当前线程被阻塞, 当全局标志位变为 true 之后,

        // 线程被唤醒, 继续往下执行打印线程编号id.

        std::cout << "thread " << id << '\n';

    }

     

    void go()

    {

        std::unique_lock <std::mutex> lck(mtx);

        ready = true// 设置全局标志位为 true.

        cv.notify_all(); // 唤醒所有线程.

    }

     

    int main()

    {

        std::thread threads[10];

        // spawn 10 threads:

        for (int i = 0; i < 10; ++i)

            threads[i] = std::thread(do_print_id, i);

     

        std::cout << "10 threads ready to race...\n";

        go(); // go!

     

      for (auto & th:threads)

            th.join();

     

        return 0;

    }</std::mutex></std::mutex></condition_variable></mutex></thread></iostream></code>

    std::condition_variable_any 介绍

    与 std::condition_variable类似,只不过std::condition_variable_any的 wait 函数可以接受任何 lockable参数,而 std::condition_variable只能接受 std::unique_lock类型的参数,除此以外,和std::condition_variable几乎完全一样。

    std::cv_status枚举类型介绍

    cv_status::no_timeout wait_for 或者wait_until没有超时,即在规定的时间段内线程收到了通知。

    ?

    1

    2

    <code class="hljs bash">cv_status::timeout  wait_for 或者 wait_until 超时。

    std::notify_all_at_thread_exit</code>

    函数原型为:

    ?

    1

    <code class="hljs bash">void notify_all_at_thread_exit (condition_variable& cond, unique_lock<mutex> lck);</mutex></code>

    当调用该函数的线程退出时,所有在 cond 条件变量上等待的线程都会收到通知。请看下例(参考):

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    <code class="hljs cpp">#include <iostream>           // std::cout

    #include <thread>             // std::thread

    #include <mutex>              // std::mutex, std::unique_lock

    #include <condition_variable> // std::condition_variable

     

    std::mutex mtx;

    std::condition_variable cv;

    bool ready = false;

     

    void print_id (int id) {

      std::unique_lock<std::mutex> lck(mtx);

      while (!ready) cv.wait(lck);

      // ...

      std::cout << "thread " << id << '\n';

    }

     

    void go() {

      std::unique_lock<std::mutex> lck(mtx);

      std::notify_all_at_thread_exit(cv,std::move(lck));

      ready = true;

    }

     

    int main ()

    {

      std::thread threads[10];

      // spawn 10 threads:

      for (int i=0; i<10; ++i)

        threads[i] = std::thread(print_id,i);

      std::cout << "10 threads ready to race...\n";

     

      std::thread(go).detach();   // go!

     

      for (auto& th : threads) th.join();

     

      return 0;

    }

    </std::mutex></std::mutex></condition_variable></mutex></thread></iostream></code>

    好了,到此为止, 头文件中的两个条件变量类(std::condition_variablestd::condition_variable_any)、枚举类型(std::cv_status)、以及辅助函数(std::notify_all_at_thread_exit())都已经介绍完了

    展开全文
  • PyTorch中的Variable类型

    2019-12-03 17:39:22
    之前在莫烦的教程中看到了Variable类型的变量,后来看PyTorch的《Deep Learning with PyTorch: A 60 Minute Blitz》教程时,作者们都没有使用Variable类型,于是我就感觉很奇怪,于是就请教了一下度娘~ 2PyTorch中...
  • pytorch之numpy,tensor,variable转换

    千次阅读 2018-06-07 21:55:43
    1.将numpy矩阵转换为Tensor张量 locs= torch.from_numpy(loc) #loc为numpy类型 2.将Tensor张量转化为numpy矩阵 locs1 = locs.numpy() ...locs2= Variable(torch.from_numpy(locs1)) 4.将Varia...
  • tensorflow tf.Variable()和tf.get_variable()详解

    万次阅读 多人点赞 2018-07-26 22:29:53
    tf.Variable是一个Variable类。通过变量维持图graph的状态,以便在sess.run()中执行;可以用Variable类创建一个实例在图中增加变量; Args参数说明: initial_value:Tensor或可转换为Tensor的Python对象,它是...
  •   张量(Tensor)是TensorFlow的核心数据单位。一个张量由一组形成阵列(任意维数)的原始值组成。张量的阶是它的维数,而它的...- tf.Variable - tf.constant - tf.placeholder tf.Variable   Tensorflo...
  • 在旧版本, Variable和Tensor分离, Tensor主要是多维矩阵的封装, 而Variable类是计算图上的节点, 它对Tensor进行了进一步的封装. 所以, 在训练过程中, 一个必要的步骤就是, 把Tensor转成Variable以便在模型中运行; ...
  • torch.autograd方法类Variable

    万次阅读 2017-08-23 14:24:44
    torch.autograd提供实现任意标量值功能的自动区分的和功能。 它需要对现有代码进行最小的更改,只需将所有张量包装在Variable对象中。 Variable API与常规Tensor API几乎相同(除了几个需要对梯度计算的输入进行...
  • C++11中std::condition_variable的使用

    万次阅读 多人点赞 2017-06-24 23:27:56
    C++11中std::condition_variable的使用
  • tf.Variable用法详解

    千次阅读 2019-03-12 23:49:10
    通过创建Variable类的实例向graph中添加变量。 Variable()需要初始值,一旦初始值确定,那么该变量的类型和形状都确定了。 更改值通过assign方法。 想要改变形状,需要使用assign+validate_shape=False。 想要...
  • TF:tensorflow框架中常用函数介绍—tf.Variable()和tf.get_variable()用法及其区别 目录 tensorflow框架 tensorflow.Variable()函数 tensorflow.get_variable()函数 tensorflow框架 tf.Variable()和tf....
  • tf.Variable是一个Variable类 通过变量维持图graph的状态,以便在sess.run()中执行;可以用Variable类创建一个实例在图中增加变量; Args:   initial_value:Tensor或可转换为Tensor的Python对象,它是Variable...
  • 相关的包括 std::condition_variable 和 std::condition_variable_any,还有枚举类型std::cv_status。另外还包括函数 std::notify_all_at_thread_exit(),下面分别介绍一下以上几种类型。 std::co...
  • 的定义:声明和体。基本格式如下: class 类名{ 体 } 特点: 1、是Java程序的基本要素,一个Java应用程序就是由若干个所构成; 2、声明的变量称为对象变量,也简称 对象 ; 3、class 关键字是...
  • static variablevariable不在同一片存储空间。 当你多次实例化同一个时,所有的实例共用的同一个static variable
  • 详解tf.variable_scope函数

    万次阅读 2018-12-21 17:01:30
    variable_scope 用于定义创建变量(层)的操作的上下文管理器。 此上下文管理器验证(可选)values是否来自同一图形,确保图形是默认的图形,并推送名称范围和变量范围。 如果name_or_scope不是None,则使用as i.....
  • TensorFlow学习笔记(六)Variable变量

    千次阅读 2017-07-28 09:59:08
    你通过构造variable 的实例来添加一个变量到图中。 Variable() 构造器需要一个初始值,可以是任意类型和shape 的Tensor。初始值定义了变量的type和shape。构造完成之后,变量的type和shape 是固定的。可以使用...
  • 浅谈Pytorch中的Variable的使用方法

    千次阅读 2020-06-19 17:51:10
    autograd.Variable 是包的核心。它包装了张量,并且支持几乎所有的操作。一旦你完成了你的计算, 就可以调用 .backward() 方法 来自动计算所有的梯度。你还可以通过 .data 属性来访问原始的张量,而关于该 ...
  • 使用OpenCL在GPU上运行的向量(RandomVariable)。 使用OpenCL启用finmath lib(通过jocl)。 -在GPU上运行finmath lib模型。 finmath lib opencl扩展提供了与finmath lib 5.1或更高版本兼容的接口Random...
  • 错误3 :error MSB4036: 未找“SetEnvironmentVariable”任务。请检查下列各项: 1.) 项目文件中的任务名称与任务的名称相同。2.) 任务为“public”且实现Microsoft.Build.Framework.ITask 接口。3.) 在项目文件...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 250,116
精华内容 100,046
关键字:

variable类