Torch 학습 노트

Torch 노트 (2) 빠 른 입문
Torch 의 유일한 데이터 구 조 는 Tensor 입 니 다. 이 구 조 는 간결 하고 강력 하 며 행렬 류 의 수치 계산 에 매우 적합 합 니 다. Torch 에서 가장 중요 한 유형 입 니 다.이 Tensor 는 사실 다 차원 행렬 로 행렬 의 각종 조작 을 지원 합 니 다.여기 서 특별히 강조해 야 할 것 은 lua 의 배열 (사실은 table) 아래 표 시 는 1 에서 시작 되 기 때문에 Tensor 대상 의 아래 표 시 는 1 에서 시작 된다 는 것 이다.우 리 는 프로그램 원숭이 의 측면 에서 볼 때 먼저 Tensor 도 유형 이 있다. Tensor 가족 은 ByteTensor, CharTensor, Short Tensor, IntTensor, LongTensor, Float Tensor, DoubleTensor 등 몇 명의 구성원 이 있 는데 내 가 말 하지 않 아 도 글자 의 뜻 을 보면 이런 Tensor 각 식 이 무슨 뜻 을 나타 내 는 지 알 수 있다.기본적으로 DoubleTensor 입 니 다. 계산 이 편리 하기 위해 서 죠?그 다음 에 Tensor 의 구조 함수 입 니 다. 어떻게 Tensor 를 만 듭 니까? 자주 사용 하 는 것 은 다음 과 같 습 니 다.Torch 가 설 치 된 기계 에 "th" 명령 을 입력 하여 Torch 환경 에 들 어 갑 니 다.

th> a = torch.Tensor(2,4);print(a)
 0  0  0  0
 0  0  0  0
[torch.DoubleTensor of size 2x4]

th> a = torch.Tensor(2,4,2)                                                         
th> print(b)
(1,.,.) = 
  6.9414e-310  6.9414e-310
  5.0872e-317  2.3253e+251
  5.0450e+223  1.6304e-322
  6.9414e-310  5.0873e-317

(2,.,.) = 
  1.0277e-321  2.3715e-322
  5.0873e-317  5.9416e-313
  5.0873e-317   8.5010e-96
  6.9677e+252  1.6304e-322
[torch.DoubleTensor of size 2x4x2]

th> c = torch.IntTensor(2,3);print(c) --        
 1.0302e+07  0.0000e+00  1.7000e+09
 1.1000e+02  0.0000e+00  0.0000e+00
[torch.IntTensor of size 2x3]

torch.Tensor(sz1 [,sz2 [,sz3 [,sz4]]]])

위의 구조 함 수 는 sz1 x sz2 x sx3 x sz4 x... 의 N 차원 Tensor 를 만 드 는 것 입 니 다. 예 를 들 어 상기 Tensor 대상 b 는 2 x 4 x 2 의 3 차원 Tensor 입 니 다. 그러나 이렇게 정의 할 뿐 초기 화 되 지 않 았 기 때문에 할당 작업 이 필요 합 니 다.

th> torch.Tensor({{1,2,3,4}, {5,6,7,8}})
 1  2  3  4
 5  6  7  8
[torch.DoubleTensor of dimension 2x4]

위 는 lua 의 table 로 초기 화 되 어 있 습 니 다. 즉, 아래 형식 입 니 다.

torch.Tensor(table)

텐서 대상 을 사용 하여 초기 화 할 수도 있 습 니 다.

torch.Tensor(tensor)

각 Tensor 간 의 전환

th> a = torch.IntTensor({3,4,5,3,3});b = torch.DoubleTensor({3.3,4.9,3.2});c = b:typeAs(a);print(c);print(b)    
 3
 4
 3
[torch.IntTensor of size 3]

 3.3000
 4.9000
 3.2000
[torch.DoubleTensor of size 3]

Tensor 에서 요소 의 유형 변환 은 단순 한 숫자 가 아 닌 Tensor 대상 으로 돌아 가 는 것 을 주의 하 십시오.

[Tensor] byte(), char(), short(), int(), long(), float(), double()

Torch 에 Storage 클래스 도 있 는데 사실은 C 언어 에 대응 하 는 1 차원 배열 입 니 다. 일반 파일 작업 에 사용 되 고 공간 을 절약 하지만 관련 함수 가 풍부 하지 않 습 니 다. 이런 부분 에 ByteStorage, CharStorage, Short Storage, IntStorage, LongStorage, Float Storage, DoubleStorage 도 있 습 니 다. 대기 유형, 용법 과 Tensor 의 차이 가 많 지 않 습 니 다.Storage 는 1 차원 배열 에 해당 하기 때문에 다 차원 배열 을 만 들 수 있 습 니 다. (여기 도 초기 화 되 지 않 았 습 니 다)

th> x =torch.Tensor( torch.LongStorage({2,3,4}));print(x) 
(1,.,.) = 
  1.1132e+171  6.1707e-114  8.8211e+199  1.0167e-152
  5.7781e-114  7.3587e+223   2.9095e-14   6.9117e-72
  8.8211e+199  1.0167e-152   3.9232e-85   6.9183e-72

(2,.,.) = 
  1.3923e-259  2.2831e-109  1.6779e+243  7.3651e+228
  2.2082e-259  1.1132e+171  6.1707e-114  2.3253e+251
  5.0450e+223  2.8811e+159   1.1995e-22  2.1723e-153
[torch.DoubleTensor of size 2x3x4]

Tensor 대상 이 조작 할 때 C + + 에서 인용 하 는 것 과 같 기 때문에 그 자체 의 값 을 바 꿀 수 있 습 니 다. 모든 경우 백업 복사 작업 을 해 야 합 니 다. Lua 에서 "의 미 를 나타 내 는 것 은 클래스 의 구성원 을 나타 내 는 것 입 니 다."가방 (N, torch, optim) 등 그 중의 함 수 를 사용 할 때 만 ".." 을 사용 합 니 다.

th> a = torch.randn(3);b = a:clone();print(a,b)
-0.7112
 0.1953
-2.0389
[torch.DoubleTensor of size 3]

-0.7112
 0.1953
-2.0389
[torch.DoubleTensor of size 3]

Tensor 의 차원 dim (), 그리고 각 차원 의 구체 적 인 수치 size () 를 가 져 옵 니 다. 아래 에 표 시 된 Tensor a 의 1 차원 은 size (1) = 2, 2 차원 은 size (2) = 4 입 니 다.Tensor 요소 의 총 갯 수 nElement () 가 져 오기

th> a = torch.Tensor(2,4):zero();print(a);print(a:dim())
 0  0  0  0
 0  0  0  0
[torch.DoubleTensor of size 2x4]

2

th> print(a:size())                            
 2
 4
[torch.LongStorage of size 2]

th> print(a:nElement())
8

아래 표 시 된 접근 방식

x = torch.Tensor(3,3)
i = 0; x:apply(function() i = i + 1; return i end)
> x
 1  2  3
 4  5  6
 7  8  9
[torch.DoubleTensor of dimension 3x3]

> x[2] -- returns row 2
 4
 5
 6
[torch.DoubleTensor of dimension 3]

> x[2][3] -- returns row 2, column 3
6

> x[{2,3}] -- another way to return row 2, column 3
6

> x[torch.LongStorage{2,3}] -- yet another way to return row 2, column 3
6

요소 복사, 두 Tensor 의 요소 총수 만 같 으 면 됩 니 다. 행렬 모양 은 다 를 수 있 습 니 다.

x = torch.Tensor(4):fill(1)
y = torch.Tensor(2,2):copy(x)
> x
 1
 1
 1
 1
[torch.DoubleTensor of dimension 4]

> y
 1  1
 1  1
[torch.DoubleTensor of dimension 2x2]

Tensor 를 동적 으로 확장 해 야 할 때 유용 한 함수 resize (sz1 [, sz2 [, sz3 [, sz4]]]])

th> x = torch.randn(2,4):zero();print(x);print(x:resize(3,4))  
 0  0  0  0
 0  0  0  0
[torch.DoubleTensor of size 2x4]

  0.0000e+00   0.0000e+00   0.0000e+00   0.0000e+00
  0.0000e+00   0.0000e+00   0.0000e+00   0.0000e+00
 8.8211e+199  7.4861e-114   2.9085e-33  1.0251e+170
[torch.DoubleTensor of size 3x4]

아래 소 개 된 narrow (dim, index, size), sub (dim1s, dim1e..index 는 시작 위치 이 고 끝 위 치 는 index + size - 1 입 니 다.

th>3.5> x = torch.Tensor(5, 6):zero();y = x:narrow(1, 2, 3);y:fill(1);print(y);print(x)
 1  1  1  1  1  1
 1  1  1  1  1  1
 1  1  1  1  1  1
[torch.DoubleTensor of size 3x6]

 0  0  0  0  0  0
 1  1  1  1  1  1
 1  1  1  1  1  1
 1  1  1  1  1  1
 0  0  0  0  0  0
[torch.DoubleTensor of size 5x6]

th> x = torch.Tensor(5, 6):zero();y = x:narrow(2, 2, 3);y:fill(1);print(y);print(x) 
 1  1  1
 1  1  1
 1  1  1
 1  1  1
 1  1  1
[torch.DoubleTensor of size 5x3]

 0  1  1  1  0  0
 0  1  1  1  0  0
 0  1  1  1  0  0
 0  1  1  1  0  0
 0  1  1  1  0  0
[torch.DoubleTensor of size 5x6]

sub 중의 dim1s 는 첫 번 째 차원 의 시작 위 치 를 나타 내 고 dim1e 는 첫 번 째 차원 의 끝 위 치 를 나타 내 며 모두 마이너스 가 될 수 있다. - 1 은 마지막 위 치 를 나타 내 고 - 2 는 마지막 두 번 째 위 치 를 나타 낸다.

th> x = torch.Tensor(5, 6):zero();z = x:sub(2,4,3,4):fill(2);print(z);print(x)
 2  2
 2  2
 2  2
[torch.DoubleTensor of size 3x2]

 0  0  0  0  0  0
 0  0  2  2  0  0
 0  0  2  2  0  0
 0  0  2  2  0  0
 0  0  0  0  0  0
[torch.DoubleTensor of size 5x6]

select (dim, index) 가 되 돌아 오 는 Tensor 는 원래 의 Tensor 보다 1 차원 이 적 고 dim 은 여전히 몇 번 째 차원 을 나타 낸다.

th> x = torch.Tensor(5,6):zero();y = x:select(1, 2):fill(2);print(y);print(x)
 2
 2
 2
 2
 2
 2
[torch.DoubleTensor of size 6]

 0  0  0  0  0  0
 2  2  2  2  2  2
 0  0  0  0  0  0
 0  0  0  0  0  0
 0  0  0  0  0  0
[torch.DoubleTensor of size 5x6]

th> x = torch.Tensor(2,3,4):zero();y = x:select(1, 2):fill(2);print(y);print(x)   
 2  2  2  2
 2  2  2  2
 2  2  2  2
[torch.DoubleTensor of size 3x4]

(1,.,.) = 
  0  0  0  0
  0  0  0  0
  0  0  0  0

(2,.,.) = 
  2  2  2  2
  2  2  2  2
  2  2  2  2
[torch.DoubleTensor of size 2x3x4]

그리고 아래 표 조작 자 [{dim 1, dim 2,...}] or [{dim 1 s, dim 1 e}, {dim 2 s, dim 2}}] 도 Tensor 를 되 돌려 줍 니 다. 이런 방식 은 더욱 간결 하고 자주 사용 합 니 다.

th> x = torch.Tensor(3, 4):zero();x[{ 1,3 }] = 1;print(x) --  x[1][3] = 1   
 0  0  1  0
 0  0  0  0
 0  0  0  0
[torch.DoubleTensor of size 3x4]

th>3.5> x = torch.Tensor(3, 4):zero();x[{ 2,{2,4} }] = 1;print(x) -- 2     index = 2，｛2，4｝     index 2 4            
 0  0  0  0
 0  1  1  1
 0  0  0  0
[torch.DoubleTensor of size 3x4]

th>3.5> x = torch.Tensor(3, 4):zero();x[{ {},2 }] = torch.range(1,3);print(x)  -- ｛｝          index，2       index = 2 range   Tensor IDTensor
 0  1  0  0
 0  2  0  0
 0  3  0  0
[torch.DoubleTensor of size 3x4]

th> x = torch.Tensor(3, 4):fill(5);x[{ {},2 }] = torch.range(1,3);x[torch.lt(x,3)] = -2;print(x) ; 
 5 -2  5  5
 5 -2  5  5
 5  3  5  5
[torch.DoubleTensor of size 3x4]

index (dim, index) 함수 가 다 릅 니 다. 되 돌아 오 는 Tensor 는 새로운 Tensor 입 니 다. 원래 의 Tensor 와 관계 가 없습니다. 여기 index 는 비교적 특수 합 니 다. LongTensor 형식 이 어야 합 니 다.

th> x = torch.randn(3,5);print(x);y = x:index(2,torch.range(2,4):typeAs(torch.LongTensor()));y:mul(100);print(y);print(x)
 0.6146 -0.3204 -1.2182  1.5573 -0.7232
-1.1692 -0.0071  3.1590  0.6008  0.4566
 0.1957 -0.4057  2.0835 -0.3365 -1.3541
[torch.DoubleTensor of size 3x5]

 -32.0396 -121.8182  155.7330
  -0.7097  315.9025   60.0773
 -40.5727  208.3459  -33.6517
[torch.DoubleTensor of size 3x3]

 0.6146 -0.3204 -1.2182  1.5573 -0.7232
-1.1692 -0.0071  3.1590  0.6008  0.4566
 0.1957 -0.4057  2.0835 -0.3365 -1.3541
[torch.DoubleTensor of size 3x5]

th>x = torch.randn(3,5);print(x);y = x:index(2,torch.LongTensor({1,4}));y:mul(100)print(y);print(x) --         index = 1  index = 4   Tensor  1   4     Tensor
-0.4880 -1.6397 -0.3257 -0.5051 -0.1214
-0.4002  1.3845  0.4411  0.1753  2.0174
 0.5882  0.9351 -0.7685  0.6377 -1.7308
[torch.DoubleTensor of size 3x5]

-48.8024 -50.5097
-40.0198  17.5341
 58.8207  63.7730
[torch.DoubleTensor of size 3x2]

-0.4880 -1.6397 -0.3257 -0.5051 -0.1214
-0.4002  1.3845  0.4411  0.1753  2.0174
 0.5882  0.9351 -0.7685  0.6377 -1.7308
[torch.DoubleTensor of size 3x5]

indexCopy (dim, index, tensor) 는 tensor 를 복사 합 니 다. index 도 LongTensor 형식 입 니 다. 유사 한 함수 로 indexAdd (dim, index, tensor), indexFill (dim, index, val) 도 있 습 니 다.

th> x = torch.randn(3,5);print(x);y = torch.Tensor(2,5);y:select(1,1):fill(-1);y:select(1,2):fill(-2);print(y);x:indexCopy(1,torch.LongTensor{3,1},y);print(x)
 0.8086  1.7714 -1.6337  0.2549  0.2131
 1.4018 -0.9938  0.3035  1.6247 -0.1368
 0.3516 -1.3728 -0.5203  0.2754 -1.6965
[torch.DoubleTensor of size 3x5]

-1 -1 -1 -1 -1
-2 -2 -2 -2 -2
[torch.DoubleTensor of size 2x5]

-2.0000 -2.0000 -2.0000 -2.0000 -2.0000
 1.4018 -0.9938  0.3035  1.6247 -0.1368
-1.0000 -1.0000 -1.0000 -1.0000 -1.0000
[torch.DoubleTensor of size 3x5]

여기 서 강조해 야 할 것 은 2 차원 Tensor 의 두 번 째 차원 이 1 일 때 이 Tensor 는 2 차원 입 니까?

--       Tensor
th> a = torch.Tensor({1,2,3,4,5});print("dim=" .. a:dim());print(a);print(a:size()) 
dim=1
 1
 2
 3
 4
 5
[torch.DoubleTensor of size 5]
 5
[torch.LongStorage of size 1]
[torch.LongStorage of size 1]
--        Tensor ，   5x1   Tensor 
th> x = torch.Tensor({1,2,3,4,5});y = x:reshape(a:size(1),1);print(y);print(y:dim())
 1
 2
 3
 4
 5
[torch.DoubleTensor of size 5x1]
2
--       
th> y = torch.Tensor({{1},{2},{3},{4},{5}});print(y);print(y:dim()) 
 1
 2
 3
 4
 5
[torch.DoubleTensor of size 5x1]
--       1x5   Tensor 
th> y = torch.Tensor({{1,2,3,4,5}});print(y);print(y:dim())                              
 1  2  3  4  5
[torch.DoubleTensor of size 1x5]
2
--        ，     Tensor ，size()         ，     ，      
th> x = torch.Tensor({1,2,3,4,5});y = x:reshape(1,a:size(1));print(y:dim());print(y);;print(y:size())
2
 1  2  3  4  5
[torch.DoubleTensor of size 1x5]
 1
 5
[torch.LongStorage of size 2]

gather (dim, index) 에서 지정 한 영역의 데 이 터 를 추출 합 니 다. 그 중에서 index 의 위 수 는 마지막 으로 출력 한 Tensor 모양 (차원, 출력 Tensor 모양 은 mxn 이 고 index 는 mxn 이 어야 합 니 다) 과 같 아야 하 며 데이터 형식 은 LongTensor 입 니 다.

-- dim = 1
result[i][j][k]... = src[index[i][j][k]...][j][k]...
-- dim = 2
result[i][j][k]... = src[i][index[i][j][k]...][k]...
-- etc.
-- src     Tensor
--              ，     nx1       （Tensor:dim() = 2）, index   nx1       LongTensor

th> x = torch.rand(5, 5);print(x);y = x:gather(1, torch.LongTensor{{1, 2, 3, 4, 5}, {2, 3, 4, 5, 1}});print(y)
 0.2188  0.3625  0.7812  0.2781  0.9327
 0.5342  0.3879  0.7225  0.6031  0.7325
 0.1464  0.4534  0.5134  0.9993  0.6617
 0.0594  0.6398  0.1741  0.7357  0.6613
 0.2926  0.7286  0.7255  0.7108  0.1820
[torch.DoubleTensor of size 5x5]

 0.2188  0.3879  0.5134  0.7357  0.1820
 0.5342  0.4534  0.1741  0.7108  0.9327
[torch.DoubleTensor of size 2x5]
--             (1,1),(2,2),(3,3),(4,4),(5,5)  1x5（  Tensor） Tensor   index = torch.LongTensor({{1, 2, 3, 4, 5}});  y = x:gather(1, index)    index 1x5   Tensor
--         (1,2),(2,3),(3,4),(4,5),(5,1) 1x5Tensor，index = torch.LongTensor({{5，1, 2, 3, 4}});  y = x:gather(1, index)  index = torch.LongTensor({{2, 3, 4, 5，1}});  y = x:gather(2, index)
--     
th> x = torch.rand(5, 5);print(x);y = x:gather(2, torch.LongTensor({ {1,2},{2,3},{3,4},{4,5},{5,1} }) );print(y)    
 0.8563  0.2664  0.6895  0.8124  0.0788
 0.0503  0.6646  0.7659  0.4013  0.0670
 0.4760  0.0517  0.9621  0.7437  0.1162
 0.4069  0.9932  0.6118  0.6200  0.3585
 0.9795  0.9601  0.9098  0.4714  0.5577
[torch.DoubleTensor of size 5x5]

 0.8563  0.2664
 0.6646  0.7659
 0.9621  0.7437
 0.6200  0.3585
 0.5577  0.9795
[torch.DoubleTensor of size 5x2]

scatter (dim, index, src | val) 는 다른 Tensor src 또는 스칼라 값 val 을 자신의 매개 변수 의미 와 gather 에 기록 하 는 것 입 니 다.

x = torch.rand(2, 5)
> x
 0.3227  0.4294  0.8476  0.9414  0.1159
 0.7338  0.5185  0.2947  0.0578  0.1273
[torch.DoubleTensor of size 2x5]

y = torch.zeros(3, 5):scatter(1, torch.LongTensor{{1, 2, 3, 1, 1}, {3, 1, 1, 2, 3}}, x)
> y
 0.3227  0.5185  0.2947  0.9414  0.1159
 0.0000  0.4294  0.0000  0.0578  0.0000
 0.7338  0.0000  0.8476  0.0000  0.1273
[torch.DoubleTensor of size 3x5]

z = torch.zeros(2, 4):scatter(2, torch.LongTensor{{3}, {4}}, 1.23)
> z
 0.0000  0.0000  1.2300  0.0000
 0.0000  0.0000  0.0000  1.2300
[torch.DoubleTensor of size 2x4]

nonzero (tensor) 는 nx2 LongTensor 를 되 돌려 줍 니 다. 원래 Tensor 의 모든 0 값 이 아 닌 아래 표 와 값 을 포함 합 니 다.

th> x = torch.rand(4, 4):mul(3):floor():int();y = torch.nonzero(x);print(x);print(y) 
 2  1  0  2
 2  1  2  1
 1  0  1  0
 2  0  2  2
[torch.IntTensor of size 4x4]

 1  1
 1  2
 1  4
 2  1
 2  2
 2  3
 2  4
 3  1
 3  3
 4  1
 4  3
 4  4
[torch.LongTensor of size 12x2]

transpose (dim 1, dim 2) 또는 직접 t () 를 설정 합 니 다. 2 차원 Tensor 에 만 유용 합 니 다. 다 차원 tensor 에 permute (dim 1, dim 2,..., dim) 를 설정 합 니 다.

x = torch.Tensor(3,4,2,5)
> x:size()
 3
 4
 2
 5
[torch.LongStorage of size 4]

y = x:permute(2,3,1,4) --     y = x:transpose(1,3):transpose(1,2)
> y:size()
 4
 2
 3
 5
[torch.LongStorage of size 4]

그리고 tensor 대상 요소 마다 함수 처리 apply (function)

 = 0
z = torch.Tensor(3,3)
z:apply(function(x)
  i = i + 1
  return i
end)
> z
 1  2  3
 4  5  6
 7  8  9
[torch.DoubleTensor of dimension 3x3]

두 개의 tensor 의 모든 요소 에 대해 map (tensor, function (xs, xt) 를 처리 합 니 다.

x = torch.Tensor(3,3)
y = torch.Tensor(9)
i = 0
x:apply(function() i = i + 1; return i end) -- fill-up x
i = 0
y:apply(function() i = i + 1; return i end) -- fill-up y
> x
 1  2  3
 4  5  6
 7  8  9
[torch.DoubleTensor of dimension 3x3]
> y
 1
 2
 3
 4
 5
 6
 7
 8
 9
[torch.DoubleTensor of dimension 9]
th> z =x:map(y, function(xx, yy) return xx*xx + yy end);print(z)
  2   6  12
 20  30  42
 56  72  90
[torch.DoubleTensor of size 3x3]

tensor 를 분할 split ([result,] tensor, size, [dim]), size 는 절 분 된 단위 (크기), dim 은 지정 한 차원, 즉 그 차원 에서 절 분 됩 니 다.

th> x = torch.randn(3,10,15) 
th> x:split(2,1)             
{
  1 : DoubleTensor - size: 2x10x15
  2 : DoubleTensor - size: 1x10x15
}
                                                                      [0.0003s]
th> x:split(4,2)             
{
  1 : DoubleTensor - size: 3x4x15
  2 : DoubleTensor - size: 3x4x15
  3 : DoubleTensor - size: 3x2x15
}
                                                                      [0.0004s]
th> x:split(5,3)    
{
  1 : DoubleTensor - size: 3x10x5
  2 : DoubleTensor - size: 3x10x5
  3 : DoubleTensor - size: 3x10x5
}

그 다음 에 일부 tensor 의 Math 조작 함수, 예 를 들 어 sum, add, sub, mul, div, mode, max, min, std, mean, pow, rand, randn, log, range, exp, abs, floor, sqrt 등 많은 Math 홈 페이지 등 함수 들 이 torch 가방 에 많이 사용 되 기 때문에 mean = torch. mean (x) 도 있 고 mean = x: mean () 도 있 습 니 다.

th> x = torch.range(1,15,3);print(x);print(x:mean());print(torch.mean(x))
  1
  4
  7
 10
 13
[torch.DoubleTensor of size 5]

7
7

또 하 나 는 torch. sort ([resval, resind,] x [, dim] [, flag]) 입 니 다. 기본 상승 순 서 는 두 개의 tensor 로 돌아 갑 니 다. 첫 번 째 는 순 서 를 배열 한 tensor 이 고 두 번 째 는 순 서 를 배열 한 tensor 입 니 다. 각 요소 에 대응 하 는 아래 표 시 된 tensor 입 니 다.

th> x = torch.Tensor({8.3,3.4,5.7,1.7,9.3});y,index = x:sort(true);print(y,index) 
--        y,index = torch.sort(x,true);print(y,index) 
 9.3000
 8.3000
 5.7000
 3.4000
 1.7000
[torch.DoubleTensor of size 5]

 5
 1
 3
 2
 4
[torch.LongTensor of size 5]

다음 Torch 는 선형 회 귀 를 실현 합 니 다.

이 내용에 흥미가 있습니까?

현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:

torch tensor 사용법

1.x = torch.Tensor(5):zero() 2.conf_mask = torch.ones(nB, nA, dim, dim) 주의: 두 번째 함수 호출 방식은 torch.Tensor(sizes, [strides]...

텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.

CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.

Torch 학습 노트

좋은 웹페이지 즐겨찾기