• 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. ])

     

     

     

  • 相关阅读:
    Mybatis-Plus ActiveRecord
    代码随想录二刷day34
    基于yolov5的手掌特效app（安卓）
    [buuctf.reverse] 126-130
    【尚品汇】项目笔记
    领域适应Domain Adaptation
    每日五道java面试题之springMVC篇（三）
    华为云云耀云服务器L实例评测｜部署在线思维导图 SimpleMindMap
    初学者理解递归
    Vue+GoJS使用初步（1）
  • 原文地址：https://blog.csdn.net/qq_40837542/article/details/127575584