深度学习(21):nerf-pytorch语法知识点记录

文章目录

  • 0 前面写的几篇
    • 前面关于nerf的一些学习:
    • 本文学习的代码:`nerf-pytorch`
  • 1 python简单语法
    • 1.1 python简单字符
    • 1.2 python切片操作
  • 3 python 函数
    • 3.1 var()函数
    • 3.2 getattr()函数
    • 3.3 sorted()函数
    • 3.4 range()函数
    • 3.5 time.time()
  • 4 PyTorch相关
    • 4.1 nn.Identity()
    • 4.2 nn.Linear
    • 4.3 nn.ModuleList 类
    • 4.4 torch.reshape()
    • 4.5 torch.randperm()
    • 4.6 numpy.random.choice()
  • 5 numpy库函数
    • 5.1 np.arange()
    • 5.2 np.meshgrid()
      • (1)自己理解
      • (2)官方解释

0 前面写的几篇

前面关于nerf的一些学习:

深度学习(20):nerf论文翻译与学习
深度学习(19):nerf论文公式理解
深度学习(18):nerf、nerf-pytorch代码运行与学习

本文学习的代码:nerf-pytorch

nerf-pytorch项目是 NeRF 的忠实 PyTorch 实现,它在运行速度提高 1.3 倍的同时重现结果。
github地址: https://github.com/yenchenlin/nerf-pytorch

1 python简单语法

1.1 python简单字符

(1){} 表示字典
(2)@ 可以表示修饰符,也可以表示矩阵乘法(不常用)
(3)//是一个算术运算符,表示整数除法,它可以返回商的整数部分(向下取整)
(4)[]表示列表
列表追加(或者说合并)
a, b = ['foo'], ['bar'] a + b

1.2 python切片操作

counts[-1]表示counts的最后一项
s[-1:] 表示序列 s 的第 -1 个元素,也即最后一个元素
s[index]—— 返回索引值为 index 的那个字符
s[start:] —— 返回从索引值为 start 开始一直到字符串末尾的所有字符
s[start:stop] —— 返回从索引值为 start 开始一直到索引值为 stop 的那个字符之前的所有字符
s[:stop] —— 返回从字符串开头一直到索引值为 stop 的那个字符之前的所有字符
s[start:stop:step] —— 返回从索引值为 start 开始一直到索引值为 stop 的那个字符之前的,以 step 为步长提取的所有字符

3 python 函数

3.1 var()函数

vars() 函数返回对象object的属性和属性值的字典对象,简言之就是将一个object转换成字典对象。

3.2 getattr()函数

函数功能是从对象object中获取名称为name的属性,等效于调用object.name

3.3 sorted()函数

可以对所有可迭代的对象进行排序操作。

3.4 range()函数

用于生成一个整数序列。
(1)range(stop) : range(10)指的是默认从0开始,步长为1,不包括10----0,1,2,3,4,5,6,7,8,9
(2)range(start,stop) :range(1,10)----1,2,3,4,5,6,7,8,9
(3)range(start,stop,step):创建一个在[start,stop)之间,步长为step,range(1,10,2) ----1,3,5,7,9

3.5 time.time()

time.time():返回当前时间的时间戳(从1970纪元开始的浮点秒数)
通过time.time()返回的时间戳做差值,可以计算一个程序运行的秒差。

4 PyTorch相关

4.1 nn.Identity()

nn.Identity() 是个函数,不是矩阵!
相当于:恒等函数 f ( x ) = x
参考:https://blog.csdn.net/OrdinaryMatthew/article/details/126741133

4.2 nn.Linear

nn.Linear定义一个神经网络的线性层,方法定义:

torch.nn.Linear(in_features, # 输入的神经元个数
           out_features, # 输出神经元个数
           bias=True # 是否包含偏置
           )

示例
定义线性层,假设输入样本数为line,样本的输入特征为5,所以in_feature=5,想让下一层的神经元个数为10,所以out_feature=10,则模型参数为: W~{5×10​}~
model = nn.Linear(in_features=5, out_features=10, bias=True)
经过线性层,其实就是做了一件事,即:
Y{line×10}​=X{line×5}​W{5×10}​+b

参考:https://blog.csdn.net/zhaohongfei_358/article/details/122797190

4.3 nn.ModuleList 类

nn.ModuleList 这个类,可以把任意 nn.Module 的子类 (比如 nn.Conv2d, nn.Linear 之类的) 加到这个 list 里面,方法和 Python 自带的 list 一样,无非是 extend,append 等操作。但不同于一般的 list,加入到 nn.ModuleList 里面的 module 是会自动注册到整个网络上的,同时 module 的 parameters 也会自动添加到整个网络中。
具体参考链接:https://zhuanlan.zhihu.com/p/64990232,讲解比较清楚

4.4 torch.reshape()

reshape函数中-1代表的是n,什么意思呢,函数中另一个参数决定了-1的值
示例:
定义3×4的张量,reshape(-1, 1),你把它想象成要转换成n×1的矩阵,即转换成了12*1的矩阵
reshape(1, -1)呢?那就是1×12
reshape(2, -1)呢?没错,那就是2×6的矩阵了
参考:https://blog.csdn.net/weixin_42599499/article/details/105896894

4.5 torch.randperm()

torch.randperm(n):将0~n-1(包括0和n-1)随机打乱后获得的数字序列,函数名是random permutation缩写

4.6 numpy.random.choice()

numpy.random.choice(a, size=None, replace=True, p=None)
从a(只要是ndarray都可以,但必须是一维的)中随机抽取数字,并组成指定大小(size)的数组
replace:True表示可以取相同数字,False表示不可以取相同数字
数组p:与数组a相对应,表示取数组a中每个元素的概率,默认为选取每个元素的概率相同。
参考:https://blog.csdn.net/ImwaterP/article/details/96282230

5 numpy库函数

5.1 np.arange()

np.arange([start, ]stop, [step, ]dtype=None)
参数解释:
start:起点值;可忽略不写,默认从0开始
stop:终点值;生成的元素不包括结束值
step:步长;可忽略不写,默认步长为1
dtype:默认为None,设置显示元素的数据类型

不同参数个数情况介绍:
一个参数时,参数值为终点值,起点取默认值0,步长取默认值1。
两个参数时,第一个参数为起点值,第二个参数为终点,步长取默认值1。
三个参数时,第一个参数为起点,第二个参数为终点,第三个参数为步长,其中步长支持小数。
参考:https://blog.csdn.net/qq_45154565/article/details/115690186

5.2 np.meshgrid()

(1)自己理解

np.meshgrid(a, b,indexing = "xy") 函数会返回 b.shape() 行 ,a.shape() 列的二维数组。
因此 i, j 都是 b.shape()行 a.shape() 列 的二维数组。

(2)官方解释

参考:https://numpy.org/doc/stable/reference/generated/numpy.meshgrid.html
代码:numpy.meshgrid(*xi, copy=True, sparse=False, indexing='xy')
作用:给定一维坐标数组 x1、x2、…、xn,制作 N 维坐标数组以对 N 维网格上的 N 维标量/矢量场进行矢量化评估。

参数:
x1, x2,…, xn:array_like
表示网格坐标的一维数组。

indexing:{'xy', 'ij'}, optional
可选参数,用于设置输出的是笛卡尔(‘xy’,默认)还是矩阵(‘ij’)索引。
此函数通过索引关键字参数支持两种索引约定。
给出字符串“ij”返回一个带有矩阵索引的网格,而“xy”返回一个带有笛卡尔索引的网格。
在输入长度为 M 和 N 的二维情况下,对于“xy”索引,输出形状为 (N, M),对于“ij”索引,输出形状为 (M, N)。
在输入长度为 M、N 和 P 的 3-D 情况下,对于“xy”索引,输出的形状为 (N, M, P),对于“ij”索引,输出的形状为 (M, N, P)。

简单示例

import numpy as np
x = [1, 2, 3, 4]
y = [7, 8, 9]

X, Y = np.meshgrid(x, y) 
print("X:")
print(X)
print("Y:")
print(Y)
print("==============================")
X1, Y1 = np.meshgrid(x, y,indexing='xy') 
print("X1:")
print(X1)
print("Y1:")
print(Y1)
print("==============================")
X2, Y2 = np.meshgrid(x, y,indexing='ij') 
print("X2:")
print(X2)
print("Y2:")
print(Y2)  
"""
结果输出:
X:
[[1 2 3 4]
 [1 2 3 4]
 [1 2 3 4]]
Y:
[[7 7 7 7]
 [8 8 8 8]
 [9 9 9 9]]
==============================
X1:
[[1 2 3 4]
 [1 2 3 4]
 [1 2 3 4]]
Y1:
[[7 7 7 7]
 [8 8 8 8]
 [9 9 9 9]]
==============================
X2:
[[1 1 1]
 [2 2 2]
 [3 3 3]
 [4 4 4]]
Y2:
[[7 8 9]
 [7 8 9]
 [7 8 9]
 [7 8 9]]
"""

sparse:bool, optional 默认false
简单示例

import numpy as np
x = [1, 2, 3, 4]
y = [7, 8, 9]

X, Y = np.meshgrid(x, y,sparse=True) 
print("X:")
print(X)
print("Y:")
print(Y)
"""
结果输出:
X:
[[1 2 3 4]]
Y:
[[7]
 [8]
 [9]]
"""

meshgrid 对于评估网格上的函数非常有用。如果函数依赖所有坐标,可以使用参数 sparse=True 来节省内存和计算时间。
简单示例:

import numpy as np
x = [1, 2, 3, 4]
y = [7, 8, 9]

X, Y = np.meshgrid(x, y,sparse=True) 
zs = np.sqrt(X**2 + Y **2)
print("X.shape,Y.shape,zs.shape",X.shape,Y.shape,zs.shape)
print("==============================")
X1, Y1 = np.meshgrid(x, y,sparse=False) 
zz = np.sqrt(X1**2 + Y1 **2)
print("X1.shape,Y1.shape,zz.shape",X1.shape,Y1.shape,zz.shape)
print("==============================")
print(np.array_equal(zz, zs))
"""
结果输出:
X.shape,Y.shape,zs.shape (1, 4) (3, 1) (3, 4)
==============================
X1.shape,Y1.shape,zz.shape (3, 4) (3, 4) (3, 4)
==============================
True
"""

你可能感兴趣的:(深度学习,论文学习,深度学习,pytorch,python,nerf,nerf-pytorch)