参考Variable变量
 
import torch
from torch.autograd import Variable
 
tensor=torch.FloatTensor([[1,2],[3,4]])
variable=Variable(tensor,requires_grad=True)
 
这里可以写这个variable是否自动计算梯度
 
print(tensor)
 
 
print(variable)
 
 
t_out=torch.mean(tensor*tensor)
v_out=torch.mean(variable*variable)
 
反向传播v_out
 
v_out.backward()
print(variable.grad)
 

 具体计算梯度如下
 v_out=1/4sum(varvar)
 d(v_out)/d(var)=1/42variable=variable/2
 这里variable.backward默认retain_graph=False第二次调用会失败，如果后续还要用要改为true
 
 

 
什么是Variable变量?
 
- 变量是内存中的一个存储区域
 
- 这个存储区域内的数据允许在同一类型范围内不断变化
 
- 是程序最基本的存储单元，包含三个要素【变量类型】【变量名】【存储的值】
 
为什么需要变量？
 
- 在内存中短暂的存储我们需要的数据
 
如何使用变量？
 
- Java的变量需要先声明，再使用
 
- 使用变量名来访问这块区域的数据
 
- 变量能作用的范围只在所声明的一个作用域当中
 
- 作用域：在定义的一对{}内
 
- 同一个作用域内不能重复命名变量
 
packagecn.dai;public classVariable {public static voidmain(String[] args) {//声明一个变量
 
inti;//为这个变量进行赋值
 
i = 10;//直接在声明的同时为其赋值
 
int a = 20;
 
// 这些变量只能作用在这个main方法之内！！
 
}
 
}
 
Java变量的分类:
 
总体分为 【基本数据类型】 和 【引用数据类型】
 
基本数据类型 PrimitiveType
 
空类型　　void
 
布尔型　　boolean
 
字符型　　char
 
数值型 【整型】&【浮点型】
 
整形　　byte　　short　　int 　　long
 
浮点型　　float　　double
 
引用数据类型 ReferenceType
 
类　　class
 
抽象类　　abstract class
 
枚举类　　enum
 
接口　　interface
 
数组　　array
 
整数类型：
 
byte　　占用1个字节 1个字节等于8个比特位 能表示的数范围 -128 ~ 127 【-27到 27-1之间】
 
short　　2个字节 　　-215到 215-1之间
 
int　　4个字节 　　-231到 231-1之间
 
long　　8个字节　　 -263到 263-1之间
 
浮点类型：
 
- 本质上说浮点型不是数值类型，只是一个近似值
 
float　　4字节
 
double　　8字节
 
字符类型：
 
char　　2字节
 
- Java 声明字符变量的值时，必须使用单引号修饰''
 
- 转义字符可以被字符char视为一个字符
 
- 也可以使用unicode的具体值表示字符
 
关于字符集的详细介绍：
 
布尔类型
 
boolean　　值：true - false
 
- 本质只是1和0，在分支和循环的条件表达式是可以使用1和0表示
 
空类型
 
void　　值：null
 
- 特殊的基本数据类型 表示无
 
类型转换
 
自动类型转换和强制类型转换
 
自动转换
 
- 根据类型可容纳的数据大小来判断 ，容量小的即是低数据类型，容量大的即是高数据类型
 
- void 和 boolean 不能参与类型转换
 
- 当小类型要转换为大类型时,编译器允许默认自动转换　　byte > short > int > long > float > double
 
- 使用 byte、short、char、 默认的自动转换是int
 
强制转换
 
- 使用强转符号(小类型)
 
- 强转将会导致数据类型的精度损失
 
String 字符串类型
 
- String 是一种引用类型
 
- String的值是常量！不是变量
 
- 值用双引号修饰，表示为字符串
 
- String 的 + 表示的是拼接，而不是数值相加
 
进制
 
- 底层实际上只有二进制存在 1010101010
 
- 二进制【binary】
 
- 八进制【octal】
 
- 十进制【decimal】
 
- 十六进制【hex】

作者主页(文火冰糖的硅基工坊)：文火冰糖（王文兵）的博客_文火冰糖的硅基工坊_CSDN博客
 
本文网址：https://blog.csdn.net/HiWangWenBing/article/details/120240309
 

目录
 
第1章 Variable变量
 
1.1 为什么需要引入Variable
 
1.2 什么是Variable
 
1.3 普通tensor与Variable在深度学习中各种的用途
 
第2章 Variable的定义
 
2.1 Variable所在的module
 
2.2 Variable的定义：Variable就是Tensor
 
2.3 tensor与variable的进一步比较
 
2.4 把variable转换以成numpy
 
待续..........: variable的自动求导
 


第1章 Variable变量
 
1.1 为什么需要引入Variable
 
Tensor是Pytorch的一个完美组件(可以生成高维数组)，可以对张量进行各种并行运算。
 
但是要构建神经网络，进行自动求导和反向传播，光有Tensor还是远远不够的，需要引入一个具备自动求导新特新的数据结构Variable。
 
 
1.2 什么是Variable
 
Variable是对Tensor的一个封装，因此Tensor具备的操作，Variable都具备。
 
Variable还引入了三个额外的属性：
 
data：Variable变量用于存放变量本身的数值
grad：Variable变量用于存放变量针对某一个函数f的偏导数值.
grad_fn：计算梯度的函数
Tensor对Variable类型的指示
 
requires_grad=True
 
1.3 普通tensor与Variable在深度学习中各种的用途
 
 
（1）普通tensor：
 
存放输入的样本数据
存放输出的结果数据
中间边的临时数据
（2）Variable变量
 
专门存放神经网络模型的参数w，b
 
1.4 Variable与Tensor的整合
 
在最新的Pytorch中，Variable整合到了Tensor中。
 
Variable和Tensor具备了相同的数据结构，普通的tensor也具备如下的三个属性。
 
data：Variable变量对应tensor的数据，必须是一个数值，不能是数值序列
grad：Variable变量对应tensor的梯度，多元函数时，不同的变量又不同的偏导函数
grad_fn：该变量对应的自动推导的导函数，多元函数时，不同的变量又不同的偏导函数
 
它们的差别是：
 
Variable默认设置requires_grad=True.
 
普通tensor默认设置requires_grad=flase
 
 
第2章 Variable的定义
 
2.1 Variable所在的module
 
Variable被定义在torch.autograd模块中。
 
#环境准备
import numpy as np
import torch
from torch.autograd import Variable

print("Hello World")
print(torch.__version__)
print(torch.cuda.is_available())
 
Hello World
1.8.0
False
 
2.2 Variable的定义：Variable就是Tensor
 
Variable可以由已有的tensor生成
 
（1）张量
 
# 生成张量
tensor_a = torch.Tensor([[1., 2.0, 3],[3.,4., 5]])
print(tensor_a)
print(tensor_a.shape)
 
tensor([[1., 2., 3.],
        [3., 4., 5.]])
torch.Size([2, 3])
 
（2）方法1
 
print("根据张量，生成variable")
var_a = torch.autograd.Variable(tensor_a, requires_grad=True)
print(var_a)
print(var_a.shape)

print("\n根据张量，生成variable")
var_b = torch.autograd.Variable(tensor_a, requires_grad=False)
print(var_b)
print(var_b.shape)
 
根据张量，生成variable
tensor([[1., 2., 3.],
        [3., 4., 5.]], requires_grad=True)
torch.Size([2, 3])

根据张量，生成variable
tensor([[1., 2., 3.],
        [3., 4., 5.]])
torch.Size([2, 3])
 
备注：variable就是张量。
 
 
（3）方法2
 
print("根据张量，生成variable")
var_c = Variable(tensor_a, requires_grad=True)
print(var_c)
print(var_c.shape)

print("\n根据张量，生成variable")
var_d = Variable(tensor_a, requires_grad=False)
print(var_d)
print(var_d.shape)
 
根据张量，生成variable
tensor([[1., 2., 3.],
        [3., 4., 5.]], requires_grad=True)
torch.Size([2, 3])

根据张量，生成variable
tensor([[1., 2., 3.],
        [3., 4., 5.]])
torch.Size([2, 3])
 
备注：
 
variable就是张量
variable是requires_grad=true的张量
 
2.3 tensor与variable的进一步比较
 
print(tensor_a.grad)
print(var_a.grad)
print(var_b.grad)
print(var_c.grad)
print(var_d.grad)
 
None
None
None
None
None
 
print(tensor_a.grad_fn)
print(var_a.grad_fn)
print(var_b.grad_fn)
print(var_c.grad_fn)
print(var_d.grad_fn)
 
None
None
None
None
None
 
print(tensor_a.data)
print(var_a.data)
print(var_b.data)
print(var_c.data)
print(var_d.data)
 
tensor([[1., 2., 3.],
        [3., 4., 5.]])
tensor([[1., 2., 3.],
        [3., 4., 5.]])
tensor([[1., 2., 3.],
        [3., 4., 5.]])
tensor([[1., 2., 3.],
        [3., 4., 5.]])
tensor([[1., 2., 3.],
        [3., 4., 5.]])
 
 
2.4 把variable转换以成numpy
 
x_variable = Variable(torch.Tensor([-3, -2,-1,0, 1, 2, 3]), requires_grad = True)
print(x_variable)

x_numpy = x_variable.data.numpy()
print(x_numpy)
 
tensor([-3., -2., -1.,  0.,  1.,  2.,  3.], requires_grad=True)
 [-3. -2. -1.  0.  1.  2.  3.]
  
 
待续..........: variable的自动求导
 

作者主页(文火冰糖的硅基工坊)：文火冰糖（王文兵）的博客_文火冰糖的硅基工坊_CSDN博客
 
本文网址：https://blog.csdn.net/HiWangWenBing/article/details/120240309

首先，在Java中我们常用 constant 来定义一个常量，用 Variable 来定义变量。
 
 
Constant 常量
 
1.常量的概念：不变化的量，及不被人修改的量
2.常量的分析：
 （1）字面值常量（掌握）
 （2）自定义常量（了解）
3.注意事项：区分字符串常量和字符常量
 字符串常量： “HelloWorld”
 字符常量： ’a‘
 
 
 
补充两个快捷方式：
 – main方法的快捷键：psvm
 – 输出语句的快捷键： sout
 
 
常量：
 
        ***概述：***
            在程序的运行过程中，其值不会发生改变的量。
        ***字面值常量分类：***
            1.字符串常量，值要用“” 括起来， “abc”
            2.字符常量，值要用’‘括起来，    ’a‘，’0‘
            3.整数常量， 10，20
            4.小数常量，1，2
            5.布尔常量，值只有两个，true和false
            6.空常量，null  目前只做了解。
 
public class ConstantDemo {
    /*
        Constant   常量
        1.常量的概念：不变化的量，及不被人修改的量
        2.常量的分析：
            （1）字面值常量（掌握）
            （2）自定义常量（了解）

        3.注意事项：区分字符串常量和字符常量
            字符串常量： "HelloWorld"
            字符常量：   ’a‘
        补充两个快捷方式：
            main方法的快捷键：psvm
            输出语句的快捷键： sout
        常量：
            概述：
                在程序的运行过程中，其值不会发生改变的量。
            字面值常量分类：
                1.字符串常量，值要用“” 括起来， “abc”
                2.字符常量，值要用’‘括起来，    ’a‘，’0‘
                3.整数常量， 10，20
                4.小数常量，1，2
                5.布尔常量，值只有两个，true和false
                6.空常量，null  目前只做了解。
    * */
    public static void main(String[] args) {
        //1.字符串常量
        System.out.println("abc");
        System.out.println("123");

        //字符常量
        System.out.println('a');
        System.out.println('0');

        //整数常量
        System.out.println(10);
        System.out.println(-10);

        //小数常量
        System.out.println(1.2);
        System.out.println(-12.3);

        //布尔常量
        System.out.println(true);
        System.out.println(false);

    }

}
 
Variable 变量
 
 
 
 
变量的定义和使用
 
 
 
    1.变量的概念：
    
        在程序执行的过程中，其值可以在某个范围内发生改变的量
        
        变量的本质，是内存中的一小块区域
        
    2.变量定义的格式：数据类型 变量 = 初始化值；
    
            变量名：每个变量都有一个名字，方便存取
            
            初始化值：使用变量前，需要给变量赋值
            
    3.数据类型的概念：变量变化的范围就是数据类型
    
    4.变量的使用：直接通过变量名来使用变量。
 
public class VariableDemo {
    //Variable 变量
    /*
    变量的定义和使用
        1.变量的概念：
            在程序执行的过程中，其值可以在某个范围内发生改变的量
            变量的本质，是内存中的一小块区域
        2.变量定义的格式：数据类型 变量 = 初始化值；
                变量名：每个变量都有一个名字，方便存取
                初始化值：使用变量前，需要给变量赋值
        3.数据类型的概念：变量变化的范围就是数据类型
        4.变量的使用：直接通过变量名来使用变量。
    */
    public static void main(String[] args) {
        //定义变量，记录学生个数
        //变量的定义格式：数据类型 变量名 = 初始化值
        int number = 12;
        //使用变量
        System.out.println(number);
    }
}