• Python Record

    1. partial 

    1. from functools import partial
    2.   
    3. # A normal function
    4. def f(a, b, c, x):
    5.     print("a",a)
    6.     print("b",b)
    7.     print("c",c)
    8.     print("x",x)
    9.     return 1000*a + 100*b + 10*c + x
    10.   
    11. # A partial function that calls f with
    12. g = partial(f, 3, 1, x=4)
    13.  
    14. # Calling g()
    15. print(g(5))

     a= 3, b=1, c=5, x=4, 3154

    2. nn. LayerNorm

    1. torch.nn.LayerNorm(normalized_shape, eps=1e-05, 
    2.                     elementwise_affine=True, device=None, dtype=None)

          normalized_shape (int or list or torch.Size) –input shape from an expected input of size

             [∗×normalized_shape[0]×normalized_shape[1]×…×normalized_shape[−1]]

    • If a single integer is used, it is treated as a singleton list, and this module will normalize over the last dimension which is expected to be of that specific size.

    • eps – a value added to the denominator for numerical stability. Default: 1e-5

    • elementwise_affine – a boolean value that when set to True, this module has learnable per-element affine parameters initialized to ones (for weights) and zeros (for biases). Default: True.

    1. # NLP Example
    2. batch, sentence_length, embedding_dim = 20, 5, 10
    3. embedding = torch.randn(batch, sentence_length, embedding_dim)
    4. layer_norm = nn.LayerNorm(embedding_dim)
    5. # Activate module
    6. layer_norm(embedding)
    7. # Image Example
    8. N, C, H, W = 20, 5, 10, 10
    9. input = torch.randn(N, C, H, W)
    10. # Normalize over the last three dimensions (i.e. the channel and spatial dimensions)
    11. # as shown in the image below
    12. layer_norm = nn.LayerNorm([C, H, W])
    13. output = layer_norm(input)

    3. a or b

    1. t1=None
    2. t2=2
    3. t1= t1 or t2
    4. print(t1)

    Results: 2 

    1. t1=1
    2. t2=2
    3. t1= t1 or t2
    4. print(t1)

    Results:1 

    4. nn.GELU

    torch.nn.GELU(approximate='none')

    Applies the Gaussian Error Linear Units functionwhere \Phi(x)Φ(x) is the Cumulative Distribution Function for Gaussian Distribution.

    1. >>> m = nn.GELU()
    2. >>> input = torch.randn(2)
    3. >>> output = m(input)

    5. nn.Dropout

    torch.nn.Dropout(p=0.5, inplace=False)
    1. >>> m = nn.Dropout(p=0.2)
    2. >>> input = torch.randn(20, 16)
    3. >>> output = m(input)

    6. nn.linspace

    1. # Importing the PyTorch library
    2. import torch
    3.  
    4. # Applying the linspace function and
    5. # storing the resulting tensor in 't'
    6. a = torch.linspace(3, 10, 5)
    7. print("a = ", a)
    8.  
    9. b = torch.linspace(start =-10, end = 10, steps = 5)
    10. print("b = ", b)

    a =  tensor([ 3.0000,  4.7500,  6.5000,  8.2500, 10.0000])
b =  tensor([-10.,  -5.,   0.,   5.,  10.])

    7. nn.indetity

    1. seed =4
    2. m = nn.Identity()
    3. input = torch.randn(4,4)
    4. output = m(input)
    5. print("m",m)
    6. print("input",input)
    7. print("output",output)
    8. print(output.size())

    8. nn.init.trunc_normal_()

    torch.nn.init.trunc_normal_(tensor, mean=0.0, std=1.0, a=- 2.0, b=2.0)

     Fills the input Tensor with values drawn from a truncated normal distribution. The values are effectively drawn from the normal distribution

     \mathcal{N}(\text{mean}, \text{std}^2)N(mean,std2) 

    with values outside [a, b][a,b] redrawn until they are within the bounds. The method used for generating the random values works best when a

    \leq \text{mean} \leq ba≤mean≤b.

    9. OrderedDictT

    1. from collections import OrderedDict
    2.  
    3. print("This is a Dict:\n")
    4. d = {}
    5. d['a'] = 1
    6. d['b'] = 2
    7. d['c'] = 3
    8. d['d'] = 4
    9.  
    10. for key, value in d.items():
    11.     print(key, value)
    12.  
    13. print("\nThis is an Ordered Dict:\n")
    14. od = OrderedDict()
    15. od['a'] = 1
    16. od['b'] = 2
    17. od['c'] = 3
    18. od['d'] = 4
    19. for key, value in od.items():
    20.     print(key, value)
    21.  
    22. print("\nThis is an *****Ordered Dict:\n")
    23. od = OrderedDict([("a1",1),("b1",2),("c1",3),("d1",4)])
    24.  
    25.  
    26. for key, value in od.items():
    27.     print(key, value)

     The above three oupts are the same

    10. random.seed()

    How Seed Function Works ?

    Seed function is used to save the state of a random function, so that it can generate same random numbers on multiple executions of the code on the same machine or on different machines (for a specific seed value). The seed value is the previous value number generated by the generator. For the first time when there is no previous value, it uses current system time. 

    Using random.seed() function

    Here we will see how we can generate the same random number every time with the same seed value. 

    1. # random module is imported
    2. import random
    3. for i in range(5):
    4.  
    5. 	# Any number can be used in place of '0'.
    6. 	random.seed(0)
    7.  
    8. 	# Generated random number will be between 1 to 1000.
    9. 	print(random.randint(1, 1000))
    10.  
    11. Output:
    12. 865
    13. 865
    14. 865
    15. 865
    16. 865
    17.  
    18.  
    19. # importing random module
    20. import random
    21. random.seed(3)
    22. # print a random number between 1 and 1000.
    23. print(random.randint(1, 1000))
    24. # if you want to get the same random number again then,
    25. random.seed(3)
    26. print(random.randint(1, 1000))
    27. # If seed function is not used
    28. # Gives totally unpredictable responses.
    29. print(random.randint(1, 1000))
    30.  
    31. Output:
    32. 244
    33. 244
    34. 607

     random.seed(0)  the next random.randint(1) get same int. 

    random.seed(1)   the next random.randint(1) get different int.

    11. Tensor, List   Convert each other

    a. Tensors concate to a Tensor

    1. import torch
    2. #step: generate a tensor with shape([5,3,3,4])
    3. #      we can think B is 5, N_views is 3, Token is 3, Dim is 4
    4. a=torch.arange(5*3*3*4).reshape([5,3,3,4])
    5.  
    6.  
    7. print(a.shape)
    8. print("a=",a)
    9. torch.Size([5, 3, 3, 4])
    10. a= tensor([[[[  0,   1,   2,   3],
    11.           [  4,   5,   6,   7],
    12.           [  8,   9,  10,  11]],
    13.  
    14.          [[ 12,  13,  14,  15],
    15.           [ 16,  17,  18,  19],
    16.           [ 20,  21,  22,  23]],
    17.  
    18.          [[ 24,  25,  26,  27],
    19.           [ 28,  29,  30,  31],
    20.           [ 32,  33,  34,  35]]],
    21.  
    22.  
    23.         [[[ 36,  37,  38,  39],
    24.           [ 40,  41,  42,  43],
    25.           [ 44,  45,  46,  47]],
    26.  
    27.          [[ 48,  49,  50,  51],
    28.           [ 52,  53,  54,  55],
    29.           [ 56,  57,  58,  59]],
    30.  
    31.          [[ 60,  61,  62,  63],
    32.           [ 64,  65,  66,  67],
    33.           [ 68,  69,  70,  71]]],
    34.  
    35.  
    36.         [[[ 72,  73,  74,  75],
    37.           [ 76,  77,  78,  79],
    38.           [ 80,  81,  82,  83]],
    39.  
    40.          [[ 84,  85,  86,  87],
    41.           [ 88,  89,  90,  91],
    42.           [ 92,  93,  94,  95]],
    43.  
    44.          [[ 96,  97,  98,  99],
    45.           [100, 101, 102, 103],
    46.           [104, 105, 106, 107]]],
    47.  
    48.  
    49.         [[[108, 109, 110, 111],
    50.           [112, 113, 114, 115],
    51.           [116, 117, 118, 119]],
    52.  
    53.          [[120, 121, 122, 123],
    54.           [124, 125, 126, 127],
    55.           [128, 129, 130, 131]],
    56.  
    57.          [[132, 133, 134, 135],
    58.           [136, 137, 138, 139],
    59.           [140, 141, 142, 143]]],
    60.  
    61.  
    62.         [[[144, 145, 146, 147],
    63.           [148, 149, 150, 151],
    64.           [152, 153, 154, 155]],
    65.  
    66.          [[156, 157, 158, 159],
    67.           [160, 161, 162, 163],
    68.           [164, 165, 166, 167]],
    69.  
    70.          [[168, 169, 170, 171],
    71.           [172, 173, 174, 175],
    72.           [176, 177, 178, 179]]]])
    73.  
    74.  
    75.  
    76.  
    77. a_local2=[]
    78. a=a.reshape(3,5,3,4)
    79. print("a.reshape",a)
    80.  
    81.  
    82. a.reshape tensor([[[[  0,   1,   2,   3],
    83.           [  4,   5,   6,   7],
    84.           [  8,   9,  10,  11]],
    85.  
    86.          [[ 12,  13,  14,  15],
    87.           [ 16,  17,  18,  19],
    88.           [ 20,  21,  22,  23]],
    89.  
    90.          [[ 24,  25,  26,  27],
    91.           [ 28,  29,  30,  31],
    92.           [ 32,  33,  34,  35]],
    93.  
    94.          [[ 36,  37,  38,  39],
    95.           [ 40,  41,  42,  43],
    96.           [ 44,  45,  46,  47]],
    97.  
    98.          [[ 48,  49,  50,  51],
    99.           [ 52,  53,  54,  55],
    100.           [ 56,  57,  58,  59]]],
    101.  
    102.  
    103.         [[[ 60,  61,  62,  63],
    104.           [ 64,  65,  66,  67],
    105.           [ 68,  69,  70,  71]],
    106.  
    107.          [[ 72,  73,  74,  75],
    108.           [ 76,  77,  78,  79],
    109.           [ 80,  81,  82,  83]],
    110.  
    111.          [[ 84,  85,  86,  87],
    112.           [ 88,  89,  90,  91],
    113.           [ 92,  93,  94,  95]],
    114.  
    115.          [[ 96,  97,  98,  99],
    116.           [100, 101, 102, 103],
    117.           [104, 105, 106, 107]],
    118.  
    119.          [[108, 109, 110, 111],
    120.           [112, 113, 114, 115],
    121.           [116, 117, 118, 119]]],
    122.  
    123.  
    124.         [[[120, 121, 122, 123],
    125.           [124, 125, 126, 127],
    126.           [128, 129, 130, 131]],
    127.  
    128.          [[132, 133, 134, 135],
    129.           [136, 137, 138, 139],
    130.           [140, 141, 142, 143]],
    131.  
    132.          [[144, 145, 146, 147],
    133.           [148, 149, 150, 151],
    134.           [152, 153, 154, 155]],
    135.  
    136.          [[156, 157, 158, 159],
    137.           [160, 161, 162, 163],
    138.           [164, 165, 166, 167]],
    139.  
    140.          [[168, 169, 170, 171],
    141.           [172, 173, 174, 175],
    142.           [176, 177, 178, 179]]]])
    143.  
    144.  
    145.  
    146.  
    147.  
    148. for j in range(a.shape[0]):
    149.     a_local2.append(a[j,:,:,:])  
    150. print(torch.cat(a_local2))
    151. torch.cat(a_local2).shape   torch.Size([15, 3, 4])
    152. tensor([[[  0,   1,   2,   3],
    153.          [  4,   5,   6,   7],
    154.          [  8,   9,  10,  11]],
    155.  
    156.         [[ 12,  13,  14,  15],
    157.          [ 16,  17,  18,  19],
    158.          [ 20,  21,  22,  23]],
    159.  
    160.         [[ 24,  25,  26,  27],
    161.          [ 28,  29,  30,  31],
    162.          [ 32,  33,  34,  35]],
    163.  
    164.         [[ 36,  37,  38,  39],
    165.          [ 40,  41,  42,  43],
    166.          [ 44,  45,  46,  47]],
    167.  
    168.         [[ 48,  49,  50,  51],
    169.          [ 52,  53,  54,  55],
    170.          [ 56,  57,  58,  59]],
    171.  
    172.         [[ 60,  61,  62,  63],
    173.          [ 64,  65,  66,  67],
    174.          [ 68,  69,  70,  71]],
    175.  
    176.         [[ 72,  73,  74,  75],
    177.          [ 76,  77,  78,  79],
    178.          [ 80,  81,  82,  83]],
    179.  
    180.         [[ 84,  85,  86,  87],
    181.          [ 88,  89,  90,  91],
    182.          [ 92,  93,  94,  95]],
    183.  
    184.         [[ 96,  97,  98,  99],
    185.          [100, 101, 102, 103],
    186.          [104, 105, 106, 107]],
    187.  
    188.         [[108, 109, 110, 111],
    189.          [112, 113, 114, 115],
    190.          [116, 117, 118, 119]],
    191.  
    192.         [[120, 121, 122, 123],
    193.          [124, 125, 126, 127],
    194.          [128, 129, 130, 131]],
    195.  
    196.         [[132, 133, 134, 135],
    197.          [136, 137, 138, 139],
    198.          [140, 141, 142, 143]],
    199.  
    200.         [[144, 145, 146, 147],
    201.          [148, 149, 150, 151],
    202.          [152, 153, 154, 155]],
    203.  
    204.         [[156, 157, 158, 159],
    205.          [160, 161, 162, 163],
    206.          [164, 165, 166, 167]],
    207.  
    208.         [[168, 169, 170, 171],
    209.          [172, 173, 174, 175],
    210.          [176, 177, 178, 179]]])
    211.  
    212.  
    213.  
    214. c=torch.cat(a_local2).reshape(5,3,3,4)
    215. print("c=",c)
    216. c= tensor([[[[  0,   1,   2,   3],
    217.           [  4,   5,   6,   7],
    218.           [  8,   9,  10,  11]],
    219.  
    220.          [[ 12,  13,  14,  15],
    221.           [ 16,  17,  18,  19],
    222.           [ 20,  21,  22,  23]],
    223.  
    224.          [[ 24,  25,  26,  27],
    225.           [ 28,  29,  30,  31],
    226.           [ 32,  33,  34,  35]]],
    227.  
    228.  
    229.         [[[ 36,  37,  38,  39],
    230.           [ 40,  41,  42,  43],
    231.           [ 44,  45,  46,  47]],
    232.  
    233.          [[ 48,  49,  50,  51],
    234.           [ 52,  53,  54,  55],
    235.           [ 56,  57,  58,  59]],
    236.  
    237.          [[ 60,  61,  62,  63],
    238.           [ 64,  65,  66,  67],
    239.           [ 68,  69,  70,  71]]],
    240.  
    241.  
    242.         [[[ 72,  73,  74,  75],
    243.           [ 76,  77,  78,  79],
    244.           [ 80,  81,  82,  83]],
    245.  
    246.          [[ 84,  85,  86,  87],
    247.           [ 88,  89,  90,  91],
    248.           [ 92,  93,  94,  95]],
    249.  
    250.          [[ 96,  97,  98,  99],
    251.           [100, 101, 102, 103],
    252.           [104, 105, 106, 107]]],
    253.  
    254.  
    255.         [[[108, 109, 110, 111],
    256.           [112, 113, 114, 115],
    257.           [116, 117, 118, 119]],
    258.  
    259.          [[120, 121, 122, 123],
    260.           [124, 125, 126, 127],
    261.           [128, 129, 130, 131]],
    262.  
    263.          [[132, 133, 134, 135],
    264.           [136, 137, 138, 139],
    265.           [140, 141, 142, 143]]],
    266.  
    267.  
    268.         [[[144, 145, 146, 147],
    269.           [148, 149, 150, 151],
    270.           [152, 153, 154, 155]],
    271.  
    272.          [[156, 157, 158, 159],
    273.           [160, 161, 162, 163],
    274.           [164, 165, 166, 167]],
    275.  
    276.          [[168, 169, 170, 171],
    277.           [172, 173, 174, 175],
    278.           [176, 177, 178, 179]]]])
    279.  
    280.  
    281. a_local2=torch.cat(a_local2).reshape(5,9,4)
    282. print("torch_a.shape",a_local2.shape)
    283. print("torch_a",a_local2)
    284. torch_a.shape torch.Size([5, 9, 4])
    285. torch_a tensor([[[  0,   1,   2,   3],
    286.          [  4,   5,   6,   7],
    287.          [  8,   9,  10,  11],
    288.          [ 12,  13,  14,  15],
    289.          [ 16,  17,  18,  19],
    290.          [ 20,  21,  22,  23],
    291.          [ 24,  25,  26,  27],
    292.          [ 28,  29,  30,  31],
    293.          [ 32,  33,  34,  35]],
    294.  
    295.         [[ 36,  37,  38,  39],
    296.          [ 40,  41,  42,  43],
    297.          [ 44,  45,  46,  47],
    298.          [ 48,  49,  50,  51],
    299.          [ 52,  53,  54,  55],
    300.          [ 56,  57,  58,  59],
    301.          [ 60,  61,  62,  63],
    302.          [ 64,  65,  66,  67],
    303.          [ 68,  69,  70,  71]],
    304.  
    305.         [[ 72,  73,  74,  75],
    306.          [ 76,  77,  78,  79],
    307.          [ 80,  81,  82,  83],
    308.          [ 84,  85,  86,  87],
    309.          [ 88,  89,  90,  91],
    310.          [ 92,  93,  94,  95],
    311.          [ 96,  97,  98,  99],
    312.          [100, 101, 102, 103],
    313.          [104, 105, 106, 107]],
    314.  
    315.         [[108, 109, 110, 111],
    316.          [112, 113, 114, 115],
    317.          [116, 117, 118, 119],
    318.          [120, 121, 122, 123],
    319.          [124, 125, 126, 127],
    320.          [128, 129, 130, 131],
    321.          [132, 133, 134, 135],
    322.          [136, 137, 138, 139],
    323.          [140, 141, 142, 143]],
    324.  
    325.         [[144, 145, 146, 147],
    326.          [148, 149, 150, 151],
    327.          [152, 153, 154, 155],
    328.          [156, 157, 158, 159],
    329.          [160, 161, 162, 163],
    330.          [164, 165, 166, 167],
    331.          [168, 169, 170, 171],
    332.          [172, 173, 174, 175],
    333.          [176, 177, 178, 179]]])
    334.  
    335.  
    336.  
    337.  
    338.  
    339.

    12. Choose a Dimension in Multi-Dimension Tensors 

    1. a=torch.arange(3*2*10).reshape([3,2,10])
    2. print("a.shape",a.shape)
    3. print("a=",a)
    4.  
    5. print("a[:,0]",a[:,0])
    6. print("a[0,:]",a[0,:])
    7.  
    8. Results:
    9.  
    10. a.shape torch.Size([3, 2, 10])
    11. a= tensor([[[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],
    12.          [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]],
    13.  
    14.         [[20, 21, 22, 23, 24, 25, 26, 27, 28, 29],
    15.          [30, 31, 32, 33, 34, 35, 36, 37, 38, 39]],
    16.  
    17.         [[40, 41, 42, 43, 44, 45, 46, 47, 48, 49],
    18.          [50, 51, 52, 53, 54, 55, 56, 57, 58, 59]]])
    19. a[:,0] tensor([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],
    20.         [20, 21, 22, 23, 24, 25, 26, 27, 28, 29],
    21.         [40, 41, 42, 43, 44, 45, 46, 47, 48, 49]])
    22. a[0,:] tensor([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],
    23.         [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]])

    Chapter 2

    2.1  random.sample()

    1. from random import sample
    2.   
    3. # Prints list of random items of given length
    4. list1 = [1, 2, 3, 4, 5] 
    5.   
    6. print(sample(list1,3))

    Output:

    [2, 3, 5]

    Chapter 3 << pytroch>>

    3.1 transforms.Compose() 

    torchvision.transformers is pythorh packages of image preprocessing.

    Generally, Compose( ) is used to combine/intergrate multiple steps together. 

    1. #For example
    2. transformer.Compose([
    3. transforms.CenterCrop(224),
    4. transforms.RandomResizedCrop(224),
    5. transforms.ToTensor(),
    6. transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]),
    7. transforms.Resize(256),
    8. ])

     

     

     

  • 相关阅读:
    染色法判定二分图的算法
    竞赛 深度学习 python opencv 火焰检测识别
    在线客服系统统计员工的一些工作量，有哪些统计维度？
    华为数字化转型之道认知篇第一章数字化转型，华为的战略选择
    如何使用Flask搭建web程序框架并实现无公网IP远程访问本地程序
    MLC-LLM 部署RWKV World系列模型实战（3B模型Mac M2解码可达26tokens/s）
    计算机毕设（附源码）JAVA-SSM家用电器电商网站设计
    Redis 集群
    CentOS 7 安装 Redis 7
    Liunx 重置MySQL用户密码
  • 原文地址：https://blog.csdn.net/qq_40837542/article/details/127575584