You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.

Tensor-and-Variable.ipynb 34 kB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957
  1. {
  2. "cells": [
  3. {
  4. "cell_type": "markdown",
  5. "metadata": {},
  6. "source": [
  7. "# Tensor and Variable\n",
  8. "这是 PyTorch 基础的第二课,通过本次课程,你能够学会如何像使用 NumPy 一样使用 PyTorch,了解到 PyTorch 中的基本元素 Tensor 和 Variable 及其操作方式。"
  9. ]
  10. },
  11. {
  12. "cell_type": "markdown",
  13. "metadata": {},
  14. "source": [
  15. "## 把 PyTorch 当做 NumPy 用\n",
  16. "PyTorch 的官方介绍是一个拥有强力GPU加速的张量和动态构建网络的库,其主要构件是张量,所以我们可以把 PyTorch 当做 NumPy 来用,PyTorch 的很多操作好 NumPy 都是类似的,但是因为其能够在 GPU 上运行,所以有着比 NumPy 快很多倍的速度。"
  17. ]
  18. },
  19. {
  20. "cell_type": "code",
  21. "execution_count": 5,
  22. "metadata": {},
  23. "outputs": [],
  24. "source": [
  25. "import torch\n",
  26. "import numpy as np"
  27. ]
  28. },
  29. {
  30. "cell_type": "code",
  31. "execution_count": 6,
  32. "metadata": {},
  33. "outputs": [],
  34. "source": [
  35. "# 创建一个 numpy ndarray\n",
  36. "numpy_tensor = np.random.randn(10, 20)"
  37. ]
  38. },
  39. {
  40. "cell_type": "markdown",
  41. "metadata": {},
  42. "source": [
  43. "我们可以使用下面两种方式将numpy的ndarray转换到tensor上"
  44. ]
  45. },
  46. {
  47. "cell_type": "code",
  48. "execution_count": 7,
  49. "metadata": {},
  50. "outputs": [],
  51. "source": [
  52. "pytorch_tensor1 = torch.Tensor(numpy_tensor)\n",
  53. "pytorch_tensor2 = torch.from_numpy(numpy_tensor)"
  54. ]
  55. },
  56. {
  57. "cell_type": "markdown",
  58. "metadata": {},
  59. "source": [
  60. "使用以上两种方法进行转换的时候,会直接将 NumPy ndarray 的数据类型转换为对应的 PyTorch Tensor 数据类型"
  61. ]
  62. },
  63. {
  64. "cell_type": "markdown",
  65. "metadata": {},
  66. "source": [
  67. "\n"
  68. ]
  69. },
  70. {
  71. "cell_type": "markdown",
  72. "metadata": {},
  73. "source": [
  74. "同时我们也可以使用下面的方法将 pytorch tensor 转换为 numpy ndarray"
  75. ]
  76. },
  77. {
  78. "cell_type": "code",
  79. "execution_count": 8,
  80. "metadata": {},
  81. "outputs": [],
  82. "source": [
  83. "# 如果 pytorch tensor 在 cpu 上\n",
  84. "numpy_array = pytorch_tensor1.numpy()\n",
  85. "\n",
  86. "# 如果 pytorch tensor 在 gpu 上\n",
  87. "numpy_array = pytorch_tensor1.cpu().numpy()"
  88. ]
  89. },
  90. {
  91. "cell_type": "markdown",
  92. "metadata": {},
  93. "source": [
  94. "需要注意 GPU 上的 Tensor 不能直接转换为 NumPy ndarray,需要使用`.cpu()`先将 GPU 上的 Tensor 转到 CPU 上"
  95. ]
  96. },
  97. {
  98. "cell_type": "markdown",
  99. "metadata": {},
  100. "source": [
  101. "\n"
  102. ]
  103. },
  104. {
  105. "cell_type": "markdown",
  106. "metadata": {},
  107. "source": [
  108. "PyTorch Tensor 使用 GPU 加速\n",
  109. "\n",
  110. "我们可以使用以下两种方式将 Tensor 放到 GPU 上"
  111. ]
  112. },
  113. {
  114. "cell_type": "code",
  115. "execution_count": null,
  116. "metadata": {},
  117. "outputs": [],
  118. "source": [
  119. "# 第一种方式是定义 cuda 数据类型\n",
  120. "dtype = torch.cuda.FloatTensor # 定义默认 GPU 的 数据类型\n",
  121. "gpu_tensor = torch.randn(10, 20).type(dtype)\n",
  122. "\n",
  123. "# 第二种方式更简单,推荐使用\n",
  124. "gpu_tensor = torch.randn(10, 20).cuda(0) # 将 tensor 放到第一个 GPU 上\n",
  125. "gpu_tensor = torch.randn(10, 20).cuda(1) # 将 tensor 放到第二个 GPU 上"
  126. ]
  127. },
  128. {
  129. "cell_type": "markdown",
  130. "metadata": {},
  131. "source": [
  132. "使用第一种方式将 tensor 放到 GPU 上的时候会将数据类型转换成定义的类型,而是用第二种方式能够直接将 tensor 放到 GPU 上,类型跟之前保持一致\n",
  133. "\n",
  134. "推荐在定义 tensor 的时候就明确数据类型,然后直接使用第二种方法将 tensor 放到 GPU 上"
  135. ]
  136. },
  137. {
  138. "cell_type": "markdown",
  139. "metadata": {},
  140. "source": [
  141. "而将 tensor 放回 CPU 的操作非常简单"
  142. ]
  143. },
  144. {
  145. "cell_type": "code",
  146. "execution_count": null,
  147. "metadata": {
  148. "collapsed": true
  149. },
  150. "outputs": [],
  151. "source": [
  152. "cpu_tensor = gpu_tensor.cpu()"
  153. ]
  154. },
  155. {
  156. "cell_type": "markdown",
  157. "metadata": {},
  158. "source": [
  159. "我们也能够访问到 Tensor 的一些属性"
  160. ]
  161. },
  162. {
  163. "cell_type": "code",
  164. "execution_count": 5,
  165. "metadata": {},
  166. "outputs": [
  167. {
  168. "name": "stdout",
  169. "output_type": "stream",
  170. "text": [
  171. "torch.Size([10, 20])\n",
  172. "torch.Size([10, 20])\n"
  173. ]
  174. }
  175. ],
  176. "source": [
  177. "# 可以通过下面两种方式得到 tensor 的大小\n",
  178. "print(pytorch_tensor1.shape)\n",
  179. "print(pytorch_tensor1.size())"
  180. ]
  181. },
  182. {
  183. "cell_type": "code",
  184. "execution_count": 6,
  185. "metadata": {},
  186. "outputs": [
  187. {
  188. "name": "stdout",
  189. "output_type": "stream",
  190. "text": [
  191. "torch.FloatTensor\n"
  192. ]
  193. }
  194. ],
  195. "source": [
  196. "# 得到 tensor 的数据类型\n",
  197. "print(pytorch_tensor1.type())"
  198. ]
  199. },
  200. {
  201. "cell_type": "code",
  202. "execution_count": 7,
  203. "metadata": {},
  204. "outputs": [
  205. {
  206. "name": "stdout",
  207. "output_type": "stream",
  208. "text": [
  209. "2\n"
  210. ]
  211. }
  212. ],
  213. "source": [
  214. "# 得到 tensor 的维度\n",
  215. "print(pytorch_tensor1.dim())"
  216. ]
  217. },
  218. {
  219. "cell_type": "code",
  220. "execution_count": 8,
  221. "metadata": {},
  222. "outputs": [
  223. {
  224. "name": "stdout",
  225. "output_type": "stream",
  226. "text": [
  227. "200\n"
  228. ]
  229. }
  230. ],
  231. "source": [
  232. "# 得到 tensor 的所有元素个数\n",
  233. "print(pytorch_tensor1.numel())"
  234. ]
  235. },
  236. {
  237. "cell_type": "markdown",
  238. "metadata": {},
  239. "source": [
  240. "**小练习**\n",
  241. "\n",
  242. "查阅以下[文档](http://pytorch.org/docs/0.3.0/tensors.html)了解 tensor 的数据类型,创建一个 float64、大小是 3 x 2、随机初始化的 tensor,将其转化为 numpy 的 ndarray,输出其数据类型\n",
  243. "\n",
  244. "参考输出: float64"
  245. ]
  246. },
  247. {
  248. "cell_type": "code",
  249. "execution_count": 6,
  250. "metadata": {},
  251. "outputs": [
  252. {
  253. "name": "stdout",
  254. "output_type": "stream",
  255. "text": [
  256. "float64\n"
  257. ]
  258. }
  259. ],
  260. "source": [
  261. "# 答案\n",
  262. "x = torch.randn(3, 2)\n",
  263. "x = x.type(torch.DoubleTensor)\n",
  264. "x_array = x.numpy()\n",
  265. "print(x_array.dtype)"
  266. ]
  267. },
  268. {
  269. "cell_type": "markdown",
  270. "metadata": {},
  271. "source": [
  272. "\n"
  273. ]
  274. },
  275. {
  276. "cell_type": "markdown",
  277. "metadata": {},
  278. "source": [
  279. "## Tensor的操作\n",
  280. "Tensor 操作中的 api 和 NumPy 非常相似,如果你熟悉 NumPy 中的操作,那么 tensor 基本是一致的,下面我们来列举其中的一些操作"
  281. ]
  282. },
  283. {
  284. "cell_type": "code",
  285. "execution_count": 9,
  286. "metadata": {},
  287. "outputs": [
  288. {
  289. "name": "stdout",
  290. "output_type": "stream",
  291. "text": [
  292. "\n",
  293. " 1 1\n",
  294. " 1 1\n",
  295. "[torch.FloatTensor of size 2x2]\n",
  296. "\n"
  297. ]
  298. }
  299. ],
  300. "source": [
  301. "x = torch.ones(2, 2)\n",
  302. "print(x) # 这是一个float tensor"
  303. ]
  304. },
  305. {
  306. "cell_type": "code",
  307. "execution_count": 10,
  308. "metadata": {},
  309. "outputs": [
  310. {
  311. "name": "stdout",
  312. "output_type": "stream",
  313. "text": [
  314. "torch.FloatTensor\n"
  315. ]
  316. }
  317. ],
  318. "source": [
  319. "print(x.type())"
  320. ]
  321. },
  322. {
  323. "cell_type": "code",
  324. "execution_count": 11,
  325. "metadata": {},
  326. "outputs": [
  327. {
  328. "name": "stdout",
  329. "output_type": "stream",
  330. "text": [
  331. "\n",
  332. " 1 1\n",
  333. " 1 1\n",
  334. "[torch.LongTensor of size 2x2]\n",
  335. "\n"
  336. ]
  337. }
  338. ],
  339. "source": [
  340. "# 将其转化为整形\n",
  341. "x = x.long()\n",
  342. "# x = x.type(torch.LongTensor)\n",
  343. "print(x)"
  344. ]
  345. },
  346. {
  347. "cell_type": "code",
  348. "execution_count": 12,
  349. "metadata": {},
  350. "outputs": [
  351. {
  352. "name": "stdout",
  353. "output_type": "stream",
  354. "text": [
  355. "\n",
  356. " 1 1\n",
  357. " 1 1\n",
  358. "[torch.FloatTensor of size 2x2]\n",
  359. "\n"
  360. ]
  361. }
  362. ],
  363. "source": [
  364. "# 再将其转回 float\n",
  365. "x = x.float()\n",
  366. "# x = x.type(torch.FloatTensor)\n",
  367. "print(x)"
  368. ]
  369. },
  370. {
  371. "cell_type": "code",
  372. "execution_count": 13,
  373. "metadata": {},
  374. "outputs": [
  375. {
  376. "name": "stdout",
  377. "output_type": "stream",
  378. "text": [
  379. "\n",
  380. "-0.8203 -0.0328 1.8283\n",
  381. "-0.1734 -0.1873 0.9818\n",
  382. "-1.8368 -2.2450 -0.4410\n",
  383. "-0.8005 -2.1132 0.7140\n",
  384. "[torch.FloatTensor of size 4x3]\n",
  385. "\n"
  386. ]
  387. }
  388. ],
  389. "source": [
  390. "x = torch.randn(4, 3)\n",
  391. "print(x)"
  392. ]
  393. },
  394. {
  395. "cell_type": "code",
  396. "execution_count": 14,
  397. "metadata": {
  398. "collapsed": true
  399. },
  400. "outputs": [],
  401. "source": [
  402. "# 沿着行取最大值\n",
  403. "max_value, max_idx = torch.max(x, dim=1)"
  404. ]
  405. },
  406. {
  407. "cell_type": "code",
  408. "execution_count": 15,
  409. "metadata": {},
  410. "outputs": [
  411. {
  412. "data": {
  413. "text/plain": [
  414. "\n",
  415. " 1.8283\n",
  416. " 0.9818\n",
  417. "-0.4410\n",
  418. " 0.7140\n",
  419. "[torch.FloatTensor of size 4]"
  420. ]
  421. },
  422. "execution_count": 15,
  423. "metadata": {},
  424. "output_type": "execute_result"
  425. }
  426. ],
  427. "source": [
  428. "# 每一行的最大值\n",
  429. "max_value"
  430. ]
  431. },
  432. {
  433. "cell_type": "code",
  434. "execution_count": 16,
  435. "metadata": {},
  436. "outputs": [
  437. {
  438. "data": {
  439. "text/plain": [
  440. "\n",
  441. " 2\n",
  442. " 2\n",
  443. " 2\n",
  444. " 2\n",
  445. "[torch.LongTensor of size 4]"
  446. ]
  447. },
  448. "execution_count": 16,
  449. "metadata": {},
  450. "output_type": "execute_result"
  451. }
  452. ],
  453. "source": [
  454. "# 每一行最大值的下标\n",
  455. "max_idx"
  456. ]
  457. },
  458. {
  459. "cell_type": "code",
  460. "execution_count": 17,
  461. "metadata": {},
  462. "outputs": [
  463. {
  464. "name": "stdout",
  465. "output_type": "stream",
  466. "text": [
  467. "\n",
  468. " 0.9751\n",
  469. " 0.6212\n",
  470. "-4.5228\n",
  471. "-2.1997\n",
  472. "[torch.FloatTensor of size 4]\n",
  473. "\n"
  474. ]
  475. }
  476. ],
  477. "source": [
  478. "# 沿着行对 x 求和\n",
  479. "sum_x = torch.sum(x, dim=1)\n",
  480. "print(sum_x)"
  481. ]
  482. },
  483. {
  484. "cell_type": "code",
  485. "execution_count": 18,
  486. "metadata": {},
  487. "outputs": [
  488. {
  489. "name": "stdout",
  490. "output_type": "stream",
  491. "text": [
  492. "torch.Size([4, 3])\n",
  493. "torch.Size([1, 4, 3])\n"
  494. ]
  495. }
  496. ],
  497. "source": [
  498. "# 增加维度或者减少维度\n",
  499. "print(x.shape)\n",
  500. "x = x.unsqueeze(0) # 在第一维增加\n",
  501. "print(x.shape)"
  502. ]
  503. },
  504. {
  505. "cell_type": "code",
  506. "execution_count": 19,
  507. "metadata": {},
  508. "outputs": [
  509. {
  510. "name": "stdout",
  511. "output_type": "stream",
  512. "text": [
  513. "torch.Size([1, 1, 4, 3])\n"
  514. ]
  515. }
  516. ],
  517. "source": [
  518. "x = x.unsqueeze(1) # 在第二维增加\n",
  519. "print(x.shape)"
  520. ]
  521. },
  522. {
  523. "cell_type": "code",
  524. "execution_count": 20,
  525. "metadata": {},
  526. "outputs": [
  527. {
  528. "name": "stdout",
  529. "output_type": "stream",
  530. "text": [
  531. "torch.Size([1, 4, 3])\n"
  532. ]
  533. }
  534. ],
  535. "source": [
  536. "x = x.squeeze(0) # 减少第一维\n",
  537. "print(x.shape)"
  538. ]
  539. },
  540. {
  541. "cell_type": "code",
  542. "execution_count": 21,
  543. "metadata": {},
  544. "outputs": [
  545. {
  546. "name": "stdout",
  547. "output_type": "stream",
  548. "text": [
  549. "torch.Size([4, 3])\n"
  550. ]
  551. }
  552. ],
  553. "source": [
  554. "x = x.squeeze() # 将 tensor 中所有的一维全部都去掉\n",
  555. "print(x.shape)"
  556. ]
  557. },
  558. {
  559. "cell_type": "code",
  560. "execution_count": 22,
  561. "metadata": {},
  562. "outputs": [
  563. {
  564. "name": "stdout",
  565. "output_type": "stream",
  566. "text": [
  567. "torch.Size([3, 4, 5])\n",
  568. "torch.Size([4, 3, 5])\n",
  569. "torch.Size([5, 3, 4])\n"
  570. ]
  571. }
  572. ],
  573. "source": [
  574. "x = torch.randn(3, 4, 5)\n",
  575. "print(x.shape)\n",
  576. "\n",
  577. "# 使用permute和transpose进行维度交换\n",
  578. "x = x.permute(1, 0, 2) # permute 可以重新排列 tensor 的维度\n",
  579. "print(x.shape)\n",
  580. "\n",
  581. "x = x.transpose(0, 2) # transpose 交换 tensor 中的两个维度\n",
  582. "print(x.shape)"
  583. ]
  584. },
  585. {
  586. "cell_type": "code",
  587. "execution_count": 23,
  588. "metadata": {},
  589. "outputs": [
  590. {
  591. "name": "stdout",
  592. "output_type": "stream",
  593. "text": [
  594. "torch.Size([3, 4, 5])\n",
  595. "torch.Size([12, 5])\n",
  596. "torch.Size([3, 20])\n"
  597. ]
  598. }
  599. ],
  600. "source": [
  601. "# 使用 view 对 tensor 进行 reshape\n",
  602. "x = torch.randn(3, 4, 5)\n",
  603. "print(x.shape)\n",
  604. "\n",
  605. "x = x.view(-1, 5) # -1 表示任意的大小,5 表示第二维变成 5\n",
  606. "print(x.shape)\n",
  607. "\n",
  608. "x = x.view(3, 20) # 重新 reshape 成 (3, 20) 的大小\n",
  609. "print(x.shape)"
  610. ]
  611. },
  612. {
  613. "cell_type": "code",
  614. "execution_count": 24,
  615. "metadata": {
  616. "collapsed": true
  617. },
  618. "outputs": [],
  619. "source": [
  620. "x = torch.randn(3, 4)\n",
  621. "y = torch.randn(3, 4)\n",
  622. "\n",
  623. "# 两个 tensor 求和\n",
  624. "z = x + y\n",
  625. "# z = torch.add(x, y)"
  626. ]
  627. },
  628. {
  629. "cell_type": "markdown",
  630. "metadata": {},
  631. "source": [
  632. "另外,pytorch中大多数的操作都支持 inplace 操作,也就是可以直接对 tensor 进行操作而不需要另外开辟内存空间,方式非常简单,一般都是在操作的符号后面加`_`,比如"
  633. ]
  634. },
  635. {
  636. "cell_type": "code",
  637. "execution_count": 25,
  638. "metadata": {},
  639. "outputs": [
  640. {
  641. "name": "stdout",
  642. "output_type": "stream",
  643. "text": [
  644. "torch.Size([3, 3])\n",
  645. "torch.Size([1, 3, 3])\n",
  646. "torch.Size([3, 1, 3])\n"
  647. ]
  648. }
  649. ],
  650. "source": [
  651. "x = torch.ones(3, 3)\n",
  652. "print(x.shape)\n",
  653. "\n",
  654. "# unsqueeze 进行 inplace\n",
  655. "x.unsqueeze_(0)\n",
  656. "print(x.shape)\n",
  657. "\n",
  658. "# transpose 进行 inplace\n",
  659. "x.transpose_(1, 0)\n",
  660. "print(x.shape)"
  661. ]
  662. },
  663. {
  664. "cell_type": "code",
  665. "execution_count": null,
  666. "metadata": {
  667. "collapsed": true
  668. },
  669. "outputs": [],
  670. "source": [
  671. "x = torch.ones(3, 3)\n",
  672. "y = torch.ones(3, 3)\n",
  673. "print(x)\n",
  674. "\n",
  675. "# add 进行 inplace\n",
  676. "x.add_(y)\n",
  677. "print(x)"
  678. ]
  679. },
  680. {
  681. "cell_type": "markdown",
  682. "metadata": {},
  683. "source": [
  684. "**小练习**\n",
  685. "\n",
  686. "访问[文档](http://pytorch.org/docs/0.3.0/tensors.html)了解 tensor 更多的 api,实现下面的要求\n",
  687. "\n",
  688. "创建一个 float32、4 x 4 的全为1的矩阵,将矩阵正中间 2 x 2 的矩阵,全部修改成2\n",
  689. "\n",
  690. "参考输出\n",
  691. "$$\n",
  692. "\\left[\n",
  693. "\\begin{matrix}\n",
  694. "1 & 1 & 1 & 1 \\\\\n",
  695. "1 & 2 & 2 & 1 \\\\\n",
  696. "1 & 2 & 2 & 1 \\\\\n",
  697. "1 & 1 & 1 & 1\n",
  698. "\\end{matrix}\n",
  699. "\\right] \\\\\n",
  700. "[torch.FloatTensor\\ of\\ size\\ 4x4]\n",
  701. "$$"
  702. ]
  703. },
  704. {
  705. "cell_type": "code",
  706. "execution_count": 10,
  707. "metadata": {},
  708. "outputs": [
  709. {
  710. "name": "stdout",
  711. "output_type": "stream",
  712. "text": [
  713. "\n",
  714. " 1 1 1 1\n",
  715. " 1 2 2 1\n",
  716. " 1 2 2 1\n",
  717. " 1 1 1 1\n",
  718. "[torch.FloatTensor of size 4x4]\n",
  719. "\n"
  720. ]
  721. }
  722. ],
  723. "source": [
  724. "# 答案\n",
  725. "x = torch.ones(4, 4).float()\n",
  726. "x[1:3, 1:3] = 2\n",
  727. "print(x)"
  728. ]
  729. },
  730. {
  731. "cell_type": "markdown",
  732. "metadata": {},
  733. "source": [
  734. "## Variable\n",
  735. "tensor 是 PyTorch 中的完美组件,但是构建神经网络还远远不够,我们需要能够构建计算图的 tensor,这就是 Variable。Variable 是对 tensor 的封装,操作和 tensor 是一样的,但是每个 Variabel都有三个属性,Variable 中的 tensor本身`.data`,对应 tensor 的梯度`.grad`以及这个 Variable 是通过什么方式得到的`.grad_fn`"
  736. ]
  737. },
  738. {
  739. "cell_type": "code",
  740. "execution_count": 4,
  741. "metadata": {},
  742. "outputs": [],
  743. "source": [
  744. "# 通过下面这种方式导入 Variable\n",
  745. "from torch.autograd import Variable"
  746. ]
  747. },
  748. {
  749. "cell_type": "code",
  750. "execution_count": 28,
  751. "metadata": {},
  752. "outputs": [],
  753. "source": [
  754. "x_tensor = torch.randn(10, 5)\n",
  755. "y_tensor = torch.randn(10, 5)\n",
  756. "\n",
  757. "# 将 tensor 变成 Variable\n",
  758. "x = Variable(x_tensor, requires_grad=True) # 默认 Variable 是不需要求梯度的,所以我们用这个方式申明需要对其进行求梯度\n",
  759. "y = Variable(y_tensor, requires_grad=True)"
  760. ]
  761. },
  762. {
  763. "cell_type": "code",
  764. "execution_count": 29,
  765. "metadata": {
  766. "collapsed": true
  767. },
  768. "outputs": [],
  769. "source": [
  770. "z = torch.sum(x + y)"
  771. ]
  772. },
  773. {
  774. "cell_type": "code",
  775. "execution_count": 30,
  776. "metadata": {},
  777. "outputs": [
  778. {
  779. "name": "stdout",
  780. "output_type": "stream",
  781. "text": [
  782. "\n",
  783. "-2.1379\n",
  784. "[torch.FloatTensor of size 1]\n",
  785. "\n",
  786. "<SumBackward0 object at 0x10da636a0>\n"
  787. ]
  788. }
  789. ],
  790. "source": [
  791. "print(z.data)\n",
  792. "print(z.grad_fn)"
  793. ]
  794. },
  795. {
  796. "cell_type": "markdown",
  797. "metadata": {},
  798. "source": [
  799. "上面我们打出了 z 中的 tensor 数值,同时通过`grad_fn`知道了其是通过 Sum 这种方式得到的"
  800. ]
  801. },
  802. {
  803. "cell_type": "code",
  804. "execution_count": 31,
  805. "metadata": {},
  806. "outputs": [
  807. {
  808. "name": "stdout",
  809. "output_type": "stream",
  810. "text": [
  811. "Variable containing:\n",
  812. " 1 1 1 1 1\n",
  813. " 1 1 1 1 1\n",
  814. " 1 1 1 1 1\n",
  815. " 1 1 1 1 1\n",
  816. " 1 1 1 1 1\n",
  817. " 1 1 1 1 1\n",
  818. " 1 1 1 1 1\n",
  819. " 1 1 1 1 1\n",
  820. " 1 1 1 1 1\n",
  821. " 1 1 1 1 1\n",
  822. "[torch.FloatTensor of size 10x5]\n",
  823. "\n",
  824. "Variable containing:\n",
  825. " 1 1 1 1 1\n",
  826. " 1 1 1 1 1\n",
  827. " 1 1 1 1 1\n",
  828. " 1 1 1 1 1\n",
  829. " 1 1 1 1 1\n",
  830. " 1 1 1 1 1\n",
  831. " 1 1 1 1 1\n",
  832. " 1 1 1 1 1\n",
  833. " 1 1 1 1 1\n",
  834. " 1 1 1 1 1\n",
  835. "[torch.FloatTensor of size 10x5]\n",
  836. "\n"
  837. ]
  838. }
  839. ],
  840. "source": [
  841. "# 求 x 和 y 的梯度\n",
  842. "z.backward()\n",
  843. "\n",
  844. "print(x.grad)\n",
  845. "print(y.grad)"
  846. ]
  847. },
  848. {
  849. "cell_type": "markdown",
  850. "metadata": {},
  851. "source": [
  852. "通过`.grad`我们得到了 x 和 y 的梯度,这里我们使用了 PyTorch 提供的自动求导机制,非常方便,下一小节会具体讲自动求导。"
  853. ]
  854. },
  855. {
  856. "cell_type": "markdown",
  857. "metadata": {},
  858. "source": [
  859. "**小练习**\n",
  860. "\n",
  861. "尝试构建一个函数 $y = x^2 $,然后求 x=2 的导数。\n",
  862. "\n",
  863. "参考输出:4"
  864. ]
  865. },
  866. {
  867. "cell_type": "markdown",
  868. "metadata": {},
  869. "source": [
  870. "提示:\n",
  871. "\n",
  872. "$y = x^2$的图像如下"
  873. ]
  874. },
  875. {
  876. "cell_type": "code",
  877. "execution_count": 2,
  878. "metadata": {},
  879. "outputs": [
  880. {
  881. "data": {
  882. "image/png": "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\n",
  883. "text/plain": [
  884. "<Figure size 432x288 with 1 Axes>"
  885. ]
  886. },
  887. "metadata": {
  888. "needs_background": "light"
  889. },
  890. "output_type": "display_data"
  891. }
  892. ],
  893. "source": [
  894. "import numpy as np\n",
  895. "import matplotlib.pyplot as plt\n",
  896. "\n",
  897. "x = np.arange(-3, 3.01, 0.1)\n",
  898. "y = x ** 2\n",
  899. "plt.plot(x, y)\n",
  900. "plt.plot(2, 4, 'ro')\n",
  901. "plt.show()"
  902. ]
  903. },
  904. {
  905. "cell_type": "code",
  906. "execution_count": 6,
  907. "metadata": {},
  908. "outputs": [
  909. {
  910. "name": "stdout",
  911. "output_type": "stream",
  912. "text": [
  913. "tensor([4.])\n"
  914. ]
  915. }
  916. ],
  917. "source": [
  918. "import torch\n",
  919. "from torch.autograd import Variable\n",
  920. "\n",
  921. "# 答案\n",
  922. "x = Variable(torch.FloatTensor([2]), requires_grad=True)\n",
  923. "y = x ** 2\n",
  924. "y.backward()\n",
  925. "print(x.grad)"
  926. ]
  927. },
  928. {
  929. "cell_type": "markdown",
  930. "metadata": {},
  931. "source": [
  932. "下一次课程我们将会从导数展开,了解 PyTorch 的自动求导机制"
  933. ]
  934. }
  935. ],
  936. "metadata": {
  937. "kernelspec": {
  938. "display_name": "Python 3",
  939. "language": "python",
  940. "name": "python3"
  941. },
  942. "language_info": {
  943. "codemirror_mode": {
  944. "name": "ipython",
  945. "version": 3
  946. },
  947. "file_extension": ".py",
  948. "mimetype": "text/x-python",
  949. "name": "python",
  950. "nbconvert_exporter": "python",
  951. "pygments_lexer": "ipython3",
  952. "version": "3.6.8"
  953. }
  954. },
  955. "nbformat": 4,
  956. "nbformat_minor": 2
  957. }

机器学习越来越多应用到飞行器、机器人等领域,其目的是利用计算机实现类似人类的智能,从而实现装备的智能化与无人化。本课程旨在引导学生掌握机器学习的基本知识、典型方法与技术,通过具体的应用案例激发学生对该学科的兴趣,鼓励学生能够从人工智能的角度来分析、解决飞行器、机器人所面临的问题和挑战。本课程主要内容包括Python编程基础,机器学习模型,无监督学习、监督学习、深度学习基础知识与实现,并学习如何利用机器学习解决实际问题,从而全面提升自我的《综合能力》。