tensor([ -5.7881,  -8.8610,  -3.7069, -17.3945,  -8.3181, -12.3195,  -3.9997,
         -6.0780, -14.2048,  -6.4304,  -5.7810,  -5.4741, -47.7153,  -5.0161,
         -5.5378,  -9.4932,  -3.5779, -15.6839, -11.3909,  -5.1915],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-12.2007,  -6.9084,  -4.5237,  -8.1174,  -9.0710, -12.8095, -13.8200,
         -7.7144,  -5.3241,  -4.8234, -18.5424,  -5.6814, -15.5921, -23.0075,
         -8.2532,  -5.8972,  -3.5534, -11.2480,  -5.3609,  -7.3561],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-37.8345,  -3.0872,  -4.6196,  -3.4273,  -7.6924,  -9.1098,  -7.1081,
        -17.5667,  -7.7098,  -6.4211,  -5.9887,  -7.0583, -19.6170,  -8.2380,
         -7.1137,  -6.7676,  -5.8347,  -9.0688,  -5.6301, -12.1433],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.9604,  -5.1121, -10.1267,  -3.7910,  -8.2395,  -6.2588,  -9.6355,
        -12.2765, -10.4714,  -6.4816,  -6.5237,  -5.6707,  -5.5190, -19.9906,
         -8.5245,  -7.1645,  -4.7845,  -9.5922,  -5.2817, -11.4964],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.6836,  -4.6164,  -6.1116,  -8.0454,  -4.7403, -13.6784, -11.4430,
         -6.5124,  -5.3981,  -4.0749,  -3.8998, -14.1899, -30.1698,  -8.3973,
        -13.1064, -10.3122,  -9.4231,  -5.5190, -12.2518, -19.3351],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -8.9836,  -6.3918, -23.2293,  -6.3622,  -6.6797,  -4.1901,  -7.3633,
         -3.8539, -12.4488, -26.8848,  -4.9507,  -6.6666,  -6.6827,  -4.8669,
        -12.0393, -24.6492,  -5.6899,  -6.4733,  -4.2269,  -6.3922],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.4541, -15.8999, -20.7459,  -5.9960,  -3.3296,  -4.4361,  -8.7566,
         -5.6436, -14.3312, -14.5901,  -5.9420,  -7.3459,  -9.4623, -11.8404,
         -6.6526, -39.4573, -15.9509,  -5.1712,  -9.8601,  -9.3095],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.1809,  -7.0214, -21.5606,  -4.4028,  -9.1462,  -7.2461,  -4.0228,
         -9.7037, -14.7028,  -7.6233,  -3.8640,  -4.0319,  -5.0139,  -6.6282,
        -12.5106, -14.0996,  -4.6353,  -5.0473,  -6.4438,  -7.8272],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.4461, -11.4324,  -4.3310,  -8.6330, -40.9760,  -9.8377,  -3.8617,
         -7.2926,  -7.3139,  -8.2855, -31.4933, -12.6621,  -5.1460,  -7.8524,
        -10.9540,  -5.3770, -52.7179,  -6.9351,  -3.1482,  -5.4665],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-12.6033,  -9.4806,  -8.9933, -46.5616,  -8.3782,  -6.3105,  -6.5383,
         -8.8512,  -7.7542, -25.3619,  -9.4778,  -6.6153,  -5.6228,  -7.5035,
         -6.8211, -33.2167,  -5.1526,  -5.0436,  -5.2597,  -4.5806],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-13.3477,  -2.8128, -10.4258,  -9.2419,  -9.4775,  -9.2530, -17.5631,
         -7.7782,  -5.4362,  -5.0898,  -6.2185,  -5.2897, -11.1215, -30.8038,
         -8.3578,  -4.2985,  -3.9148,  -5.1791,  -6.0687, -46.5427],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.3993,  -5.6049,  -7.6482, -28.7705,  -4.9657,  -4.9528,  -5.3406,
         -5.0086, -10.3719, -27.0381,  -8.1718,  -6.0374,  -8.3363,  -6.5541,
         -9.5765, -31.6766,  -8.2483,  -5.2360,  -4.2327, -10.5178],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.1308,  -6.6983,  -4.5429, -11.1277, -14.2896,  -5.1837,  -3.1502,
         -5.2815,  -6.2911,  -4.1349, -13.4820, -14.1794,  -5.2812,  -6.4383,
         -4.9445,  -8.4286,  -6.5084,  -5.5645, -48.7144, -21.6970],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -2.5661, -10.6192,  -9.9083,  -5.4377,  -6.6872,  -5.4940,  -4.4646,
        -20.3905,  -6.1494,  -3.9757,  -4.8476,  -6.3805,  -4.8823, -23.5283,
         -8.2393,  -4.7680,  -7.1259,  -7.7466, -10.3810, -40.2881],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.5873, -14.6082,  -3.8003,  -9.4413,  -5.7091,  -4.6115, -11.1169,
        -29.0510,  -6.6568,  -8.7873,  -6.5667,  -9.0013,  -4.2898, -56.7067,
         -6.1187,  -3.6010,  -6.0715,  -4.5517,  -4.3053, -12.3852],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.1842,  -5.5231,  -4.7679,  -8.0238,  -7.6727,  -4.0380, -23.5022,
         -5.6976,  -6.5752,  -8.3815,  -3.2993,  -7.1515,  -9.1476,  -5.5173,
         -3.4697,  -3.0213,  -7.0503,  -3.6943,  -4.2487, -22.0437],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.5853,  -3.7991, -11.3831,  -6.3237, -10.2038,  -5.3723,  -2.7781,
        -21.4782,  -7.1502,  -5.6572,  -4.7527,  -4.2721,  -4.7075,  -8.4030,
         -3.0808,  -5.7016,  -8.5038, -15.1569,  -4.9807,  -4.1167],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -8.3373,  -4.8213, -12.6358, -15.2125,  -5.6241,  -5.8632,  -5.1714,
         -8.2264, -13.7788, -19.3309,  -6.9484, -11.4287,  -5.0288, -23.8731,
        -15.7161,  -3.4363,  -7.6835,  -5.0148, -25.9213,  -7.6647],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -8.7598,  -7.9309,  -5.0993, -10.6269, -15.9459,  -6.2216,  -3.9244,
         -7.8487,  -7.2628,  -5.3353, -12.9930, -21.7318,  -5.4237,  -4.0715,
         -3.6389,  -9.6184,  -7.6488,  -7.7397, -21.1388,  -8.4277],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -7.0612,  -3.7379,  -2.9928, -10.0466,  -5.8278,  -7.1067, -20.6206,
         -7.1003,  -5.3280, -10.1697,  -5.1871,  -7.6105, -25.1731,  -6.6122,
         -3.0434,  -5.8538,  -7.5199,  -6.9280,  -9.6890, -18.8150],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.1079, -36.1910,  -9.0432,  -6.1746,  -7.2044,  -4.1202, -14.2205,
        -14.6450,  -6.9282, -12.0482,  -4.9762,  -6.2771,  -7.3756,  -6.4087,
        -13.1346,  -4.1946, -29.5822,  -5.5020,  -3.5575,  -5.3878],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.0176,  -5.9196,  -9.2215,  -4.4217, -23.9058,  -6.7692,  -3.7091,
         -2.2820,  -5.1489,  -6.5509,  -9.5730,  -8.6479,  -9.9908,  -4.2898,
        -12.1930, -24.5604,  -5.4273, -10.2570,  -6.4499,  -6.7931],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-39.3886,  -6.8379,  -5.2855,  -5.2793,  -7.7969,  -4.8374, -13.2805,
        -27.5145,  -7.7848,  -3.4441,  -6.9163,  -8.6693,  -5.3343, -12.9690,
        -14.6258,  -8.5736,  -2.6680,  -4.5461,  -6.5453,  -7.1924],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -7.1122,  -3.9720, -25.5575,  -6.9085,  -3.1550,  -5.8284,  -5.2269,
         -5.2228,  -6.5119, -26.7719,  -3.4767,  -5.4444,  -7.1989,  -4.7716,
        -11.5150,  -5.4651,  -4.9449,  -5.4942,  -3.1285,  -6.7052],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -7.8966,  -8.6725,  -6.4465,  -8.0042, -13.3885, -10.8975,  -8.1510,
         -2.8866,  -4.4115,  -6.1440,  -3.9823, -12.4466, -15.2416, -11.1707,
         -8.9060,  -5.0831,  -6.4280, -11.1896, -27.1354,  -6.5820],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -7.9143,  -5.9406,  -5.9560,  -4.1169,  -7.3793,  -5.5345,  -3.9247,
         -4.0472, -10.9008,  -7.8940, -28.9285,  -8.8267,  -5.1665,  -5.7598,
         -5.2108,  -8.7051, -21.3567,  -3.0342, -10.9963,  -3.2530],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-31.5706,  -3.9071, -10.2700,  -9.9123,  -3.7204, -13.6896, -16.0555,
         -5.1236,  -5.6912,  -3.3237,  -6.1347,  -6.9468, -10.7421, -13.4528,
         -4.0163,  -6.6430,  -7.2086,  -8.0576,  -7.2668, -41.7298],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.8062, -11.5556, -15.8285, -11.4044,  -7.5844,  -3.9096, -10.1850,
         -5.3853, -10.2842, -15.0194,  -7.5023,  -6.7001,  -6.1114,  -5.4212,
        -21.1588, -12.4403,  -6.1006,  -4.7969,  -3.9304, -12.4473],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.9253, -14.0621,  -4.9699,  -4.2213,  -5.9718,  -6.0605,  -8.7002,
         -3.8046,  -4.3077,  -5.1317,  -2.7049, -16.5323,  -5.4712,  -4.9058,
         -4.0382,  -4.7768,  -8.5084,  -4.2856,  -3.4397,  -5.3363],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -9.7939,  -4.8072,  -5.6818, -10.5846,  -5.1530, -26.4526,  -9.5554,
         -6.7530,  -8.0377,  -5.0937, -13.8269, -45.8286,  -6.6280,  -5.9641,
         -5.3704, -10.5654,  -4.8435, -11.8689, -13.5023,  -5.3491],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-10.9799, -22.2686,  -8.7105,  -3.7391,  -4.2120, -11.7971,  -6.4193,
         -9.5609, -31.1433, -11.0466,  -4.4982,  -8.5374, -12.1645,  -6.5760,
        -36.0608,  -9.7359,  -3.3747,  -4.8416,  -9.9321, -16.6376],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-13.6178,  -6.1781,  -5.2397,  -5.6860,  -3.0343,  -7.2925, -25.3372,
         -7.0591,  -6.4526,  -4.9910,  -5.1541,  -6.0357, -19.0016,  -5.1966,
         -3.3180,  -5.3710,  -7.2950,  -4.9742,  -9.3339, -29.7050],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.8076,  -5.9872,  -6.1677, -16.8671, -14.3526,  -5.2933,  -3.7629,
         -5.8191,  -4.8201,  -7.9337, -10.2773,  -5.2559, -36.4294, -10.9514,
         -4.5522,  -5.1559,  -6.7701,  -7.7958, -15.7580, -27.9207],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.9691,  -4.4397,  -5.0385, -10.5346, -14.1965,  -8.2612,  -9.6813,
         -8.8145, -12.5170,  -5.0105, -28.4847,  -5.8398,  -4.6846,  -4.9432,
         -6.6094,  -6.4130, -13.2325, -23.1034,  -4.7912, -10.4382],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.2632, -11.9137,  -5.2652, -30.0726,  -7.7999,  -8.2750,  -5.0017,
         -5.9716,  -9.2577,  -6.9158,  -9.4364,  -3.4612,  -4.1121,  -4.8270,
         -4.5389,  -5.1381,  -5.5183,  -8.0286,  -4.3100, -54.6334],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-29.8228, -11.3250,  -3.7501,  -7.5429, -17.0715,  -8.1493, -11.5768,
        -51.7135, -10.4352,  -4.7248,  -5.0379,  -4.2720,  -5.3785,  -4.5426,
         -7.8961,  -6.5576, -28.9270,  -5.8162,  -5.8087,  -9.4937],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-26.2367,  -9.5293,  -5.2347,  -7.9726,  -7.0439,  -5.4213, -32.5004,
        -11.9303,  -3.6570,  -5.9441,  -9.4467,  -6.9824,  -8.1668, -20.9208,
         -6.3038,  -4.4839,  -6.4177,  -6.9805,  -4.8254, -18.1996],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -2.8909, -13.2386,  -6.8946,  -2.4870, -22.2530,  -3.5827,  -5.1115,
         -3.9851,  -5.5366,  -7.1411, -13.7758,  -8.7634,  -7.3383,  -7.9316,
        -18.1524,  -7.9444,  -6.1328,  -8.3642,  -5.6452, -12.7360],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-22.9450,  -4.6406,  -5.0394,  -7.8579,  -3.8687,  -8.5224, -24.3484,
         -5.7930,  -7.7527,  -6.0073, -11.5569,  -8.6273, -28.9952,  -6.9916,
         -3.2827,  -2.8637, -11.8767,  -7.0809,  -5.5000,  -4.8759],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -7.1549,  -6.4406,  -5.3192,  -4.2779, -11.6641, -24.8107,  -6.7473,
         -9.7564,  -6.5035,  -5.9182,  -8.4222, -18.9104,  -9.8681,  -7.8423,
         -7.6109,  -3.8466, -14.6732,  -8.6469,  -3.4571,  -5.6167],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -9.3032,  -8.0942,  -6.8570,  -5.3549,  -9.5205,  -5.7101, -11.4537,
         -6.9469,  -5.4576,  -6.5716,  -4.4121, -10.5290,  -4.3441,  -2.8257,
         -7.4780,  -3.7223, -28.2559,  -8.7950,  -5.2860, -11.6635],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-12.6001,  -5.5013,  -9.4916, -12.7368,  -8.2604,  -3.8104, -10.6737,
         -5.8511,  -5.1719, -13.6747, -23.5379,  -7.6822,  -5.3387,  -8.3185,
         -7.8861,  -9.8710, -35.2653,  -4.3692,  -4.9315,  -6.7259],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-13.8106, -24.0124,  -8.6783,  -5.1541,  -7.3787, -12.3444,  -5.4681,
        -52.5787,  -8.3745,  -6.9864,  -4.6204,  -3.4225, -22.6208,  -3.7016,
         -3.5599,  -6.7572, -49.3498,  -8.3288,  -4.1633,  -6.5095],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -2.3190,  -5.3845,  -4.2480,  -5.2951, -14.8768, -19.6930,  -8.6293,
         -7.1246, -10.4111,  -4.0520, -10.2440, -18.0409,  -6.1351,  -3.3824,
         -3.7889,  -6.8334, -11.7316, -51.0111,  -7.6713,  -5.5628],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.6854,  -4.6080,  -5.1332,  -5.8974, -40.1995,  -2.6429,  -7.0590,
         -6.7870,  -5.6773, -11.9840, -18.2204,  -4.0185,  -7.5353,  -5.6177,
         -7.0858,  -6.5684, -63.8526,  -3.7683,  -4.6034,  -3.6336],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.4207,  -4.5265,  -7.8986,  -5.7170,  -9.0276, -22.1713,  -5.8296,
         -4.4365,  -5.3577,  -4.3371, -11.4931, -23.7864,  -4.6509,  -4.4145,
         -6.1698,  -8.3333,  -4.2409, -19.0918, -17.2140,  -5.7759],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -9.3994,  -7.6418,  -8.7988, -26.0315,  -4.5143,  -6.1962, -11.0306,
         -4.0093,  -7.4286, -31.8864,  -6.7329,  -4.0151,  -5.1760,  -6.2102,
         -5.5354,  -8.6827, -25.7533,  -6.5445,  -6.1587,  -8.1710],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-18.5286,  -6.8453,  -5.3987,  -4.1795,  -6.1805,  -6.2771, -22.7780,
         -5.8866,  -8.3297,  -8.5127,  -6.0269,  -8.4056, -53.3855,  -8.3974,
         -3.6730,  -4.0433,  -5.0464,  -9.5045, -17.7572,  -5.2792],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.0945,  -7.8715, -11.6820,  -9.3582, -37.0737, -11.7676,  -4.9650,
         -8.4079,  -5.3783, -12.4345,  -6.8492,  -4.3284,  -4.8341,  -3.9551,
         -6.6684,  -6.5314, -10.7010,  -5.3479, -15.0504,  -6.7513],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.7593,  -7.3950,  -5.9449, -29.8043,  -7.5292,  -9.8277,  -5.6829,
         -8.6502, -11.2132, -16.6246,  -7.5409,  -3.2534,  -3.9963,  -5.0604,
         -8.5066,  -4.1171,  -2.1781,  -7.6979,  -5.5469, -39.6022],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-25.8092,  -6.8534,  -6.2308,  -3.9523,  -4.2554, -10.9671, -29.2493,
        -10.8561,  -5.6228,  -7.2637,  -8.0930,  -5.5377, -10.5784, -30.3358,
         -6.8739,  -4.1479,  -7.8632,  -5.6267,  -4.7228,  -9.5705],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.2610,  -4.9326,  -5.7648, -11.5747,  -5.1831,  -4.7601,  -8.8798,
         -4.7732,  -5.0887,  -3.1603,  -5.1339,  -5.5899,  -5.5610,  -4.9386,
         -6.2152,  -4.8154,  -6.7970, -11.6794,  -4.0964,  -4.5844],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.9900,  -4.1481, -10.3430,  -5.5163,  -9.5249, -23.3807,  -7.6483,
         -4.2540,  -2.5168,  -4.2732,  -9.5984, -23.5761,  -4.5421,  -8.5783,
         -7.2130,  -8.6249,  -9.6427, -30.2695,  -5.7002,  -6.2346],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -9.0655, -20.6828,  -9.8357,  -9.1306,  -4.3082,  -5.5144,  -4.9777,
         -4.1365,  -3.4639,  -3.3654,  -4.3825,  -3.7120, -10.6341, -10.2350,
         -5.0357,  -5.4154,  -3.1598, -11.6572,  -2.7840,  -4.6986],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.7270,  -9.3506, -14.9911,  -6.4376,  -6.0033,  -7.4768,  -4.4472,
        -13.7584, -19.0540,  -7.5993, -11.2477,  -4.6799,  -9.3873,  -6.6682,
         -3.8183,  -9.8647,  -3.2137, -14.4164,  -5.6881,  -4.3995],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-27.7457,  -9.0400,  -9.6685,  -8.6036,  -7.3347,  -6.7701, -34.1529,
         -7.8237,  -5.8539,  -6.8379, -10.0613,  -6.6880, -12.7455, -26.3708,
        -13.9085,  -4.3866,  -7.4537,  -5.0979,  -6.6067, -17.0349],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -7.7058,  -4.8205, -11.4572,  -5.9705, -33.9527,  -5.6460,  -4.2619,
         -1.6421,  -4.5225, -15.9100, -22.7943,  -5.5397,  -6.6861,  -5.1418,
        -10.6596,  -6.2411,  -6.0174,  -6.2289,  -3.9803, -12.1318],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-11.2916, -33.9881, -10.1160,  -4.1225,  -7.0946,  -6.4351,  -3.3719,
        -37.5420, -14.1808,  -3.3286,  -6.2979,  -6.3458,  -7.9541, -12.0469,
        -39.4338,  -9.6022,  -5.2659,  -8.2944,  -4.3605, -12.5622],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.3047,  -4.7338,  -5.4433, -32.7838,  -7.5875,  -3.6970,  -5.6507,
         -7.1492,  -4.0427, -27.0449,  -9.1032,  -8.6696,  -7.7860,  -6.7942,
        -13.8321,  -5.4180, -51.9324,  -9.1008,  -4.3482,  -6.0778],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-39.0390,  -9.9370,  -4.0554,  -2.2811,  -4.6695,  -4.9604,  -5.8247,
         -3.2010,  -8.8961,  -4.9145, -12.3670, -49.5818,  -8.8300,  -4.5911,
         -4.4649,  -6.4107,  -6.6537, -28.9579,  -4.8366,  -5.0945],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.4922, -30.6592,  -3.7843,  -4.2125, -12.9664,  -6.6375,  -3.6838,
         -7.8948,  -6.2021,  -8.6324,  -4.6024,  -3.8521,  -5.6682,  -8.2844,
         -5.7480,  -4.4633,  -6.4629,  -3.6785, -13.6362,  -5.8539],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-11.3728,  -5.6876,  -5.8026,  -3.6048,  -7.5569,  -5.1208, -14.9304,
        -38.5098,  -4.9421, -11.3188,  -7.1674,  -6.3324, -10.9695, -17.3454,
         -6.6799,  -4.9547,  -5.3337,  -8.7130,  -6.8382,  -7.3109],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -7.7604,  -5.1147, -32.9620, -10.4085,  -5.6269,  -9.1112,  -3.4999,
         -8.3663, -36.3767,  -6.8720,  -7.0278,  -3.8571,  -4.4485, -13.0675,
         -3.3474,  -5.9133,  -7.0262,  -3.6978, -22.5916,  -7.2794],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.3667,  -6.7309,  -6.9926,  -7.7039, -22.4595,  -4.9951,  -4.0175,
         -3.0387,  -6.9795,  -6.4267,  -7.1764,  -7.7732,  -7.6948,  -4.8855,
         -6.6088,  -8.4983,  -4.1458, -22.4905,  -9.1324,  -3.6803],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-54.3460, -11.9709,  -3.0668,  -7.1989,  -9.2329,  -8.7030,  -4.8018,
         -7.7748, -25.7869,  -5.0642,  -4.5048,  -7.8336, -10.0086,  -4.5363,
        -32.1555,  -6.6868,  -6.6391,  -5.2306,  -4.5943,  -4.3611],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.3631, -11.5734,  -4.8167, -13.0489, -27.2903,  -5.0709,  -4.2739,
         -8.1552,  -9.4132,  -4.9247, -49.6282,  -8.0407,  -3.6267,  -5.7987,
         -4.6763,  -8.2186, -35.4530,  -4.8075,  -7.7202,  -4.7342],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.6988,  -4.3998,  -7.9786,  -7.1096, -35.7860,  -4.0586,  -4.4982,
         -7.1444,  -7.3587,  -5.4631, -51.1111,  -5.5824,  -4.4107,  -4.7085,
         -4.0580,  -7.1370,  -4.2975,  -8.1630,  -4.1596, -14.7430],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -2.8651, -22.5397,  -6.6089,  -8.1313,  -4.6547,  -4.3717, -10.0772,
        -10.9001,  -4.3184,  -5.5746,  -4.9539,  -7.0279,  -5.3105, -11.3160,
         -4.9320,  -9.4433, -20.1530,  -6.9815,  -4.8143,  -3.3481],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.9495, -15.2101,  -5.6853,  -4.1608,  -4.3234,  -9.5322,  -4.1642,
         -4.0529,  -9.3446,  -4.9847, -11.9951,  -7.7924,  -8.0400,  -4.5577,
         -9.6331,  -9.8235,  -4.8557, -46.7603,  -5.6890,  -5.3618],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.3069,  -9.6166,  -7.3852,  -8.7501, -10.2916, -14.6187,  -7.4618,
         -5.1955,  -5.5280,  -7.2258,  -3.8517, -36.0330,  -7.3336,  -4.5852,
         -7.7536,  -6.5976,  -5.3176, -43.9182, -11.0602,  -4.8781],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.7435, -44.1231,  -9.0197,  -4.7828,  -6.0968,  -6.8095,  -6.5177,
        -10.8328, -18.1275,  -6.3603,  -6.5854,  -7.2002,  -7.1938, -11.7659,
        -20.7160,  -6.9513,  -6.5874,  -4.1294,  -6.4434,  -5.1852],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.0368,  -3.1094,  -6.3682,  -8.8715,  -5.8614,  -6.0457,  -6.2541,
        -27.7292, -10.2299,  -8.2031,  -4.6322,  -5.6019,  -5.5554,  -4.1025,
         -5.6503,  -3.8597, -20.7504,  -7.4790,  -6.7031,  -7.5555],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.1938, -17.4023, -10.6017,  -5.4598,  -3.4749,  -2.7085,  -4.7248,
         -4.4621,  -4.1917,  -6.4645,  -6.1422, -26.2912,  -7.6921,  -4.4548,
        -10.6946,  -2.6925,  -7.4229, -12.0451,  -8.0467,  -4.5856],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.9937,  -4.2129,  -5.2544,  -4.7283, -26.2262, -19.6051,  -6.0838,
         -5.9358,  -6.2401,  -7.6635,  -6.5218, -32.6508,  -6.1616,  -2.5427,
         -4.6854, -10.7070, -10.4391,  -4.9369,  -7.3555,  -6.6948],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -8.3569,  -5.3762,  -4.4661,  -5.4043,  -5.0062,  -6.7886, -25.5524,
         -5.1487,  -6.6523,  -5.0333,  -5.2304, -13.8571, -31.2709,  -4.4908,
         -4.9468,  -5.7621,  -8.0545,  -4.6209, -26.0671,  -5.3482],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.7968, -45.2063,  -5.5456,  -5.2775,  -6.3160,  -7.0414,  -6.8206,
        -11.8647, -25.0575,  -6.4498,  -5.1735,  -9.3922,  -8.0691,  -7.8299,
        -19.6770, -13.4313,  -5.2197,  -3.6502,  -8.9292,  -4.7643],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.7634,  -7.5197,  -3.5365,  -5.4587, -16.7398,  -8.4229,  -4.7003,
         -4.7778,  -7.3031, -23.2256,  -5.8734,  -4.7197,  -4.9971,  -6.1454,
         -6.3124,  -8.5754, -24.5314,  -8.7137,  -6.3922, -12.8922],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.8945, -14.1870, -22.6301,  -5.3754,  -7.2978,  -6.3796,  -3.9586,
        -10.4397, -32.6337,  -5.0263,  -5.4969,  -3.8161,  -7.4815,  -4.6353,
        -11.1045, -20.3827,  -6.9522,  -6.6911,  -7.5357,  -5.5018],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -8.5190,  -5.5265,  -4.1628, -12.7245,  -8.2639,  -6.7468,  -7.5362,
         -4.5106,  -6.2442,  -7.6374, -27.0508,  -7.8210,  -5.5101,  -7.5041,
         -8.0972, -12.3902, -23.1248,  -9.2093,  -4.0799,  -6.3010],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-26.7765,  -6.6390,  -5.5046,  -8.2253,  -5.1426, -11.4690, -17.5575,
         -5.0744,  -7.4272,  -4.2262,  -4.8603,  -6.6923,  -6.4285,  -7.8062,
         -4.6927, -29.6295,  -7.0802,  -4.1527,  -6.5497,  -5.2307],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.8972,  -4.3309,  -5.6124,  -6.5088,  -5.8921, -15.6049, -31.1073,
         -4.4577,  -4.8312,  -6.2382,  -4.3942, -14.2096,  -8.3008,  -5.1083,
         -7.1200,  -4.5588,  -4.9486, -16.2335, -29.5009,  -5.3494],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -7.2307,  -4.9522,  -4.2491,  -4.8799, -10.4010, -28.4082,  -6.5781,
         -5.7937,  -7.2491,  -8.6088,  -9.0179, -25.7674, -13.2039,  -3.9395,
         -7.7122,  -6.2774, -10.6160, -31.0665,  -5.7382,  -5.4016],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-22.4676,  -5.9869, -16.7657,  -6.8593,  -3.2425,  -7.9199, -18.4079,
         -8.8723,  -4.9183,  -5.0914,  -6.8054,  -9.1972,  -8.2030,  -7.6651,
        -24.7829,  -8.7953,  -5.4263,  -5.7622,  -5.7839,  -6.9780],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.9006, -18.4963,  -4.6974,  -4.2517,  -3.4719,  -7.1530,  -7.5983,
         -7.1239, -42.6017, -10.5120,  -5.8167,  -4.0905,  -6.1500, -10.8482,
        -28.9566,  -6.0511,  -3.3401,  -4.5540,  -5.0579,  -4.2540],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-13.1633, -17.2058,  -5.0363,  -4.9605,  -4.8372,  -5.6151,  -4.9548,
        -17.0947, -26.9676,  -6.1558, -10.5075,  -7.9296,  -4.0127, -17.2659,
        -23.6126,  -6.3384,  -4.9802,  -3.8543,  -5.2034, -14.7580],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -7.8564,  -5.8344,  -6.7742,  -4.4958, -14.2199, -26.8983,  -3.5366,
         -6.3414,  -6.4300,  -5.8327,  -4.1257, -12.8019, -27.6592,  -8.0221,
         -3.7061,  -7.2178,  -8.2658,  -3.7818, -31.5410,  -7.3206],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -8.0411,  -4.2094,  -9.4531, -16.2538,  -3.9681,  -5.4602,  -6.1061,
         -7.1912, -10.7577,  -3.8299,  -5.2927, -10.3754,  -5.2062, -47.4027,
        -13.2164,  -4.7416,  -6.3530,  -5.2720,  -7.2834, -11.8055],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.7115, -11.6227, -19.6396,  -6.1378,  -3.2266,  -3.2104,  -5.3538,
         -8.9868, -17.8614,  -3.3137, -10.1764,  -7.3851,  -3.8579, -36.0696,
         -4.0768, -10.9577,  -5.0829,  -5.0055,  -7.8740,  -7.9050],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.6360, -10.1610, -27.3181,  -7.1677,  -4.7265,  -9.4658,  -4.9927,
        -15.7759, -41.3599,  -9.7634,  -8.3598,  -6.8239,  -5.5046, -14.9743,
        -11.1116,  -7.6627,  -8.0271,  -3.6106,  -8.4624,  -7.9164],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -7.0097,  -5.6768,  -4.7629,  -4.9765, -11.6121, -19.5645,  -5.1001,
         -8.7034,  -7.2363, -10.2904,  -4.4553, -57.8285,  -7.9062,  -4.6129,
         -4.6864,  -4.3557,  -5.8051,  -2.8266, -10.0816,  -2.8869],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.8293,  -6.8155,  -6.0010,  -7.5327, -18.9384,  -6.7775,  -5.7518,
         -5.6235, -11.7136,  -6.5917, -13.2707, -23.3685,  -6.6171,  -3.6849,
         -8.7235,  -7.6568,  -6.0983,  -7.0327, -18.4155,  -6.9280],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -2.0155,  -5.1224,  -4.6613,  -8.1168, -16.6369, -12.7470,  -8.0535,
         -4.0345,  -4.0162, -11.7782, -26.3554,  -4.2698,  -3.6201,  -3.4987,
         -6.5203,  -4.8427, -15.6117, -16.1899,  -8.1175,  -5.2468],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -7.6568,  -5.4769,  -6.0886, -30.1186,  -6.4137,  -9.6120,  -9.2404,
         -2.2806,  -8.1160, -15.6866,  -5.9517,  -9.6045,  -7.4441, -14.7952,
         -9.7923,  -5.2095,  -8.1188,  -3.9521, -26.7444,  -8.6733],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.4236,  -6.2593,  -4.4459,  -5.9575,  -6.5723,  -3.4107, -14.5101,
         -8.4593,  -8.0890,  -5.1704,  -4.2542,  -4.0272,  -7.0323,  -9.1277,
         -5.6458,  -6.2408,  -5.0154, -10.9404,  -5.6568,  -4.1011],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.1809,  -7.4067,  -9.2052,  -4.8202, -15.0528, -17.1543,  -3.5291,
         -5.7780,  -4.4087,  -6.9903,  -5.6835, -32.5360,  -8.1622,  -6.8076,
         -5.9500,  -4.4407, -16.4034, -26.8854,  -5.8284,  -3.7666],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.5396, -16.5587, -12.7856,  -5.9799, -12.0682,  -3.4960, -12.3820,
         -9.1849,  -4.9856,  -3.5408,  -4.3301,  -6.5180,  -6.1742, -25.9653,
         -6.8442,  -7.8938, -12.8769,  -3.9869, -11.1190, -22.3100],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.5998, -10.2880,  -7.5513,  -7.8077,  -9.3893, -38.1835,  -5.7862,
         -4.3237,  -5.9016, -10.9214,  -6.0420,  -7.4991, -13.6530,  -5.9382,
         -9.1280,  -8.2945,  -6.0456,  -9.7714, -31.1603, -13.2433],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -7.5447,  -8.0824,  -6.9938, -23.3365,  -8.4107,  -7.1563,  -6.3526,
         -8.2617,  -8.8383, -26.1608,  -8.0639,  -4.8201,  -3.6986,  -8.8776,
         -4.8465,  -7.3440, -45.5461,  -8.0661,  -6.5773,  -7.2804],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -7.4115,  -5.8246,  -5.1713,  -7.4698,  -5.0873, -42.5569,  -9.3055,
         -8.9262, -10.3360,  -2.5736, -11.3110,  -9.6790, -12.6085,  -5.5672,
         -4.5156, -12.7329, -14.3559,  -3.4553, -11.5794,  -4.3107],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-11.6094,  -2.5729,  -6.1135, -10.9661,  -5.4209, -10.9315, -40.8768,
         -3.3111,  -4.2054,  -6.4932,  -9.4953,  -5.9415, -11.1399, -35.5381,
         -5.4066,  -3.7706,  -4.1094,  -4.7367, -11.4581, -10.4267],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -9.2265,  -6.3091,  -4.7246, -46.5549,  -9.9692,  -8.5109,  -6.8466,
         -2.9661, -16.1371, -20.4418,  -7.0284,  -9.0367,  -5.4846,  -5.2776,
         -5.4124,  -2.9755,  -1.2652,  -8.4263,  -3.9964, -33.1561],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-12.3987,  -3.9342,  -4.2151,  -7.4738,  -6.1726, -14.1262, -25.0299,
         -6.8937,  -5.6257,  -5.5836, -11.4364,  -8.8977, -38.9851, -12.0787,
         -4.8727,  -4.2700,  -8.1269,  -8.0227, -10.4777, -13.0834],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.5804,  -3.5918,  -6.0640,  -5.1931,  -9.8957, -23.1781,  -5.8694,
         -5.8739,  -6.0567,  -4.5319,  -7.8728, -31.5902,  -3.8719,  -4.7184,
         -5.1382,  -6.5827,  -5.3732, -11.7342, -24.0751,  -7.9889],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -8.1007,  -8.1118, -11.5761, -61.6366,  -6.0179,  -3.8953,  -5.4384,
         -7.6760,  -5.6918,  -6.3371, -18.6370,  -9.6540,  -6.8289,  -6.9281,
         -3.9891,  -9.7014, -19.4159,  -5.0727,  -7.2525,  -5.3269],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.4084,  -6.4387,  -6.6240,  -6.0639, -39.9356,  -5.6762,  -3.8590,
         -7.8511,  -5.3613,  -4.7638, -16.4543, -10.0582,  -6.3230,  -7.0133,
         -6.2046,  -3.6592, -21.9312,  -8.2129,  -5.9925,  -4.2486],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.5157, -10.4064, -31.0965,  -4.4679,  -4.5858,  -4.6904,  -5.6205,
        -11.7050, -29.4413,  -5.3273,  -3.7689,  -4.5619,  -4.9429,  -3.7909,
        -23.8646,  -5.2088,  -4.7342,  -4.0744,  -8.0473,  -5.3011],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-19.3873,  -4.9114,  -4.4876, -10.4757,  -7.3285, -29.1159,  -6.1452,
         -3.6542,  -3.8401,  -3.9523, -13.0773, -24.4572,  -2.8831,  -9.2189,
         -5.0097,  -3.2759, -38.6139, -15.5299, -14.0422,  -5.6695],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.1022, -16.4721, -21.2680, -10.6428,  -4.0091,  -2.7853,  -6.6700,
         -5.1931, -12.4214, -13.2046,  -5.3425,  -7.8361,  -3.9538,  -5.1100,
         -9.0589, -25.4698,  -4.4371,  -5.9005,  -4.5600,  -6.6127],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.2286,  -5.7520,  -6.4477,  -6.3683, -40.9863,  -4.7475,  -8.2650,
         -6.2712,  -7.6058,  -6.5612, -32.0079, -12.0322,  -6.2274,  -5.6912,
         -3.5099,  -7.8215, -24.1906,  -4.8740,  -4.6878,  -4.5280],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.1769,  -6.2881, -12.3750, -19.9075,  -4.5761,  -6.6129,  -9.2754,
         -6.5887,  -3.8157,  -2.7549,  -6.3151, -12.0512,  -8.2408, -32.0549,
        -10.0941,  -3.8446,  -4.3922,  -7.4551,  -5.1700, -10.3639],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-10.8118,  -4.7472,  -6.6942, -14.4009, -11.6273,  -5.9039,  -8.7592,
         -4.9898,  -8.4439, -25.4139,  -7.2386,  -5.0176,  -6.3510,  -8.7814,
         -4.2596, -42.3997, -10.5389,  -4.2510,  -6.1146,  -6.2723],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-11.0826, -42.3789,  -5.7916,  -7.0932,  -6.6664,  -8.9012,  -5.3053,
        -52.5977,  -7.9674,  -4.5106,  -4.0143, -10.6026,  -5.6531, -20.9702,
        -24.5763,  -5.3789,  -5.3366,  -6.3724,  -4.5585, -13.3679],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.4743, -10.7917, -15.0175,  -6.4468,  -4.1081,  -5.4149,  -7.5132,
         -5.2322, -13.2441, -20.9604,  -7.3512,  -7.0430,  -5.6586,  -4.6255,
         -8.5354, -28.5401,  -8.0491,  -6.5580,  -3.8531,  -8.4245],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.0792, -14.0118,  -5.4798,  -3.8685, -11.9677,  -8.9914,  -7.9301,
         -3.6208,  -5.0274,  -4.6757,  -6.3423,  -4.0874,  -4.8839,  -7.7821,
         -4.2293, -16.1992,  -8.7476,  -4.1629,  -7.6852,  -6.7203],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.9595,  -4.2214,  -6.4466,  -4.6333, -12.0956, -19.7311,  -3.3103,
         -5.4189,  -6.1390,  -6.1733, -10.3374, -42.9565,  -5.1973,  -4.5579,
         -3.3424, -11.0202,  -4.9493,  -9.2085, -28.5486,  -5.0465],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-27.6751,  -7.1908,  -4.2418,  -7.6971,  -6.1077,  -5.7288, -36.4740,
         -8.9016,  -3.5885,  -6.6541,  -6.3604,  -5.9919, -28.5748, -12.6835,
         -5.3380,  -7.9688, -13.3956,  -6.4660, -20.3550, -20.6742],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.5416, -10.1881,  -6.6450,  -9.9124,  -9.5506, -30.5372,  -6.3769,
         -8.9195,  -7.1700,  -4.5991, -15.8201, -40.9356,  -5.7389,  -3.7742,
         -7.6991,  -7.3163,  -6.2390,  -8.0044, -15.9494,  -7.9197],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-23.9662, -11.3905,  -3.8366,  -3.7055,  -3.7486,  -3.6751,  -8.0785,
         -7.3286,  -4.3908, -22.4234,  -7.9502,  -9.1956,  -6.3104,  -4.1465,
         -5.6574, -12.6948,  -4.5316,  -7.3040,  -4.3634,  -4.9231],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -7.7360,  -4.2181,  -3.1636,  -6.3289,  -4.6388, -24.5967,  -4.0008,
         -8.1790,  -5.9709,  -7.2951,  -5.3283, -12.1278, -27.0564,  -5.2227,
         -9.0304,  -5.0056,  -6.9379,  -8.4648, -34.8870,  -9.7731],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.5520,  -5.2454, -13.0231,  -5.2103,  -4.5315,  -4.9857,  -6.0522,
         -7.7766, -33.9605,  -5.6365,  -8.1948,  -8.8878,  -8.1553,  -7.6576,
        -17.3928,  -6.2574,  -2.5107,  -4.7215,  -8.4266,  -4.4298],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.8254, -28.0707, -11.3146,  -4.0352,  -5.9498,  -7.5569,  -8.6285,
         -7.5463, -30.3143,  -9.1920,  -3.1307,  -7.6751, -10.0896,  -5.7198,
         -6.7215, -28.3864,  -4.7591,  -4.5770,  -5.6706,  -5.8259],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-17.6851,  -7.7535,  -4.9137,  -3.8245,  -5.5684, -17.0307,  -6.0720,
         -8.8455, -39.2328,  -7.5766,  -5.1341,  -3.4235, -11.4266,  -6.9932,
        -12.2863, -31.1963,  -6.1961,  -3.1165,  -6.0242,  -7.1125],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.2760, -36.4563,  -7.2780,  -5.3588,  -4.9259,  -7.0663,  -5.7214,
         -8.4323, -34.3282,  -3.5935,  -5.6403,  -5.6309,  -6.9696,  -4.1482,
        -44.2316,  -5.1975,  -4.6172,  -7.2567,  -4.5036,  -6.9316],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.4563,  -7.3081,  -7.7708, -13.4938, -31.0549, -10.7088,  -2.0961,
         -2.5219,  -6.5136,  -4.5721,  -9.2944, -15.0320,  -4.6494, -10.2428,
         -4.8339,  -9.4539,  -6.3953, -31.2061,  -6.1112,  -5.8766],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.0079,  -4.3756, -12.6819, -16.0639,  -4.8700,  -7.9777,  -5.4671,
         -5.3458, -19.5936, -19.0060,  -5.4504, -11.4557,  -8.1212,  -3.0158,
        -10.6591,  -8.6215,  -5.9947,  -4.6780,  -5.3931,  -5.5581],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-53.0605,  -3.5356,  -3.7977,  -3.9196,  -3.6668,  -5.3004,  -3.7039,
         -3.9780, -10.3396,  -3.3224, -14.8941, -10.1536,  -5.6144,  -5.6197,
         -6.6479,  -4.2447, -24.0730,  -6.1354,  -6.2826,  -3.4409],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -8.1509,  -7.2383,  -6.3322, -44.9058,  -7.0388,  -2.8122,  -5.1091,
         -6.3166,  -5.5800, -12.0510, -12.7396,  -9.6065,  -6.9617,  -6.5145,
         -4.0168, -13.9795, -18.3037,  -6.1305,  -5.1675,  -5.5563],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.9379,  -4.8699, -10.2596,  -9.6721,  -3.7050, -51.2145,  -7.2059,
         -2.8688,  -6.1530,  -5.8099,  -5.8787,  -5.7679,  -7.1647,  -9.5355,
         -7.2259,  -6.7614,  -7.4019, -10.9535,  -4.0763, -46.2494],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -2.7292,  -7.1093,  -5.6000,  -5.6138, -21.3997,  -5.9568,  -3.9250,
         -3.3899,  -4.2909,  -7.1996, -23.6688,  -4.0841,  -9.3766,  -4.4876,
         -3.6596, -15.4515, -17.5654,  -5.7071,  -2.8768,  -5.4270],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -9.5825,  -6.1747,  -4.3804,  -5.9344,  -6.3928,  -5.7647, -27.2735,
         -6.9566,  -6.1015,  -4.9645,  -7.9374,  -4.1630,  -9.1789, -12.4027,
         -6.8960,  -4.2887,  -2.7698,  -3.2867,  -6.5256, -13.8659],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.2940,  -4.1199,  -4.8300, -19.4597,  -6.6480,  -3.2452,  -3.9853,
         -5.6576,  -4.8332,  -8.1791, -19.7899,  -5.3096,  -3.7566,  -5.8049,
         -5.3781,  -5.8900, -21.1947,  -5.4733,  -3.3155,  -6.0571],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -2.9697,  -3.6574,  -9.5497,  -5.9877,  -3.8968, -23.6851,  -4.8674,
         -4.0653,  -3.3938,  -5.2031,  -6.3232,  -4.6566, -16.9435,  -7.5466,
         -4.0291,  -4.1280,  -2.4733,  -9.9191, -11.1954,  -5.6926],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.0755,  -4.9197,  -9.7716, -11.1163,  -5.0970,  -3.0427,  -4.8373,
         -4.9519,  -5.9633, -12.2286,  -2.1294, -15.6032,  -7.5563,  -3.0457,
         -2.0889,  -6.0340, -15.5830,  -4.5211,  -5.2544, -15.1001],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.4513,  -4.9782,  -3.7027, -10.6741,  -5.4778, -12.6985,  -3.3153,
         -4.4314,  -5.7469,  -4.1112,  -9.7012,  -8.3880,  -6.0688,  -3.9497,
         -4.1177,  -4.5062,  -5.0588,  -8.6822, -12.1638,  -4.4601],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -2.8770,  -4.3514,  -8.0065, -10.3666,  -4.1156,  -4.0886,  -3.5476,
         -5.3026,  -4.9711, -13.8109,  -4.2447,  -6.8617,  -5.3105,  -5.7483,
         -5.8249, -16.1990,  -4.4506,  -3.5726,  -3.4475,  -6.4893],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.9517,  -4.8394,  -6.5510,  -7.9913, -11.8004,  -6.9579,  -2.5476,
         -2.0306,  -4.0827, -10.3984,  -3.2025,  -6.0878,  -2.5452, -12.7019,
         -5.5370,  -4.8941,  -3.8131,  -2.3541,  -7.3595, -20.7816],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -9.6906, -10.1566,  -7.6221,  -4.2963,  -3.3721, -13.7743,  -5.7626,
         -6.3501, -17.3276,  -5.3174,  -5.3612,  -4.7654,  -3.2814, -24.1947,
         -3.6565,  -3.2659,   0.1861,  -4.2361,  -4.0534,  -9.3557],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.4413,  -9.4677,  -7.1740,  -9.3333,  -4.3844,  -7.6640,  -5.7325,
         -4.2514,  -4.7278, -12.5931,  -7.1307,  -4.1380,  -5.7231,  -5.3800,
         -4.7886, -18.0136,  -5.8943,  -5.2535,  -6.0459,  -3.7694],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.8502,  -4.5749, -12.2466, -12.4246,  -5.4325,  -3.4803,  -5.8442,
         -3.6992, -10.9812,  -6.2944,  -7.4909,  -7.6419,  -1.5033,  -6.4681,
         -5.7944,  -4.6608,  -7.7842,  -6.3302,  -4.7364,  -4.8042],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -9.1263,  -5.1115,  -4.5106,  -1.8719, -13.8704,  -4.6974,  -5.5890,
         -7.0789,  -2.7528, -29.1610,  -3.7287,  -3.6531,  -4.2706,  -4.8846,
         -6.6073,  -7.1783, -25.4492,  -6.7014,  -5.0410,  -4.4199],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.9548,  -3.8927,  -5.6236,  -9.9165,  -7.5376,  -5.8504,  -4.0715,
         -5.1883,  -6.2413, -11.6661,  -7.8266,  -6.9732,  -5.0031,  -3.9271,
        -12.3368,  -6.9601,  -6.5311,  -5.7321,  -2.5966,  -3.7008],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-6.7040, -5.4252, -4.9245, -4.4095, -5.4541, -3.6519, -5.9601, -7.7316,
        -4.9595, -4.1498, -3.5541, -4.1102, -7.4204, -2.7713, -4.2004, -4.4765,
        -5.4826, -6.2162, -7.6436, -4.0655], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -4.8660,  -3.4718,  -3.3436,  -3.7431,  -7.4596,  -4.6198,  -4.7940,
         -4.6935,  -3.6761, -14.4536,  -4.7863,  -2.8266,  -4.3740,  -3.6336,
         -5.8857,  -3.1032,  -5.2966,  -5.1355,  -4.9350,  -3.8717],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.7696,  -4.5224,  -8.8208,  -4.5552,  -3.2476,  -6.0784,  -4.3716,
        -14.6643,  -4.4794,  -3.6706,  -4.5809,  -5.7253,  -5.5350, -19.4446,
         -5.6334,  -4.1736,  -6.4609, -10.3286,  -4.2716, -21.4845],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.0240,  -3.7898,  -8.0207,  -5.6583,  -6.3800, -18.9127,  -9.7158,
         -3.4404,  -3.2874,  -8.0671,  -7.1127, -10.6052, -20.6619,  -7.3024,
         -5.0886,  -5.3841,  -6.0336,  -7.0267, -13.0087,  -5.3544],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.5280,  -3.3118,  -5.1080,  -5.1545,  -6.1565, -19.9792,  -3.6512,
         -4.6846,  -3.7813,  -5.6703,  -3.7049, -26.7228,  -4.9062,  -3.5960,
         -4.8107,  -3.4209,  -5.1277, -21.8297,  -6.5239,  -3.8132],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.8049,  -6.3918,  -5.2407,  -4.0830, -16.0897,  -4.9137,  -5.1360,
         -3.1258,  -3.9004,  -5.6041, -14.7551,  -4.7808,  -4.0158,  -5.8752,
         -6.0355,  -4.4120,  -9.4994, -11.5287,  -4.5190,  -4.1989],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.9752,  -6.5457,  -4.1602,  -4.7472, -10.0162,  -5.2534,  -6.2101,
         -9.7073,  -5.0871,  -5.4490,  -4.4549,  -6.3948,  -4.7974, -10.7152,
        -15.6147,  -6.2030,  -4.8977,  -2.8582,  -4.2721,  -8.8038],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.2071,  -5.1604,  -4.1865, -15.5061,  -5.6244,  -4.9756,  -4.7207,
         -6.6134,  -4.6076, -23.6140,  -7.1724,  -6.0333,  -5.4478,  -6.9622,
         -3.6357, -34.2421,  -7.3539,  -3.4309,  -4.0693,  -5.4239],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.1177,  -3.6978,  -3.2698,  -4.5286,  -8.8479,  -9.0645, -13.7671,
         -4.4570,  -7.6299,  -3.5244,  -5.2082,  -3.9840, -23.2952,  -5.4369,
         -2.9133,  -4.7608,  -4.2906, -10.3753, -10.8783,  -5.6720],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.0044,  -3.4413,  -5.4510,  -5.3793,  -7.0298, -16.2614,  -5.8258,
         -4.0259,  -5.2041,  -5.3200,  -5.4477, -23.8810,  -5.3186,  -4.4950,
         -3.9367,  -8.6342,  -6.9919,  -6.5142, -14.8430,  -4.6523],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-26.5520,  -5.8313,  -3.0226,  -5.5159,  -8.1884,  -6.4346,  -6.4935,
        -20.8457,  -5.6110,  -4.2001,  -3.5895, -11.9035,  -3.1825, -21.4722,
         -8.3446,  -4.2960,  -4.2101,  -9.1468,  -6.2056,  -4.9465],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-16.8067,  -5.5069,  -4.3462,  -4.3922, -10.5295,  -4.1195,  -8.0093,
         -8.7655,  -5.1817,  -3.8497,  -4.2988,  -8.7222,  -5.4628,  -7.0724,
        -18.2784,  -5.9335,  -3.5572,  -6.1635,  -4.4815, -12.3436],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-23.6617,  -5.3556,  -4.7240,  -3.7895,  -5.6654,  -3.6917, -19.8230,
         -7.3479,  -5.2058,  -3.5810,  -5.5382,  -6.0417, -16.2096,  -5.9108,
         -4.9856,  -4.3299,  -8.5439,  -5.2056,  -8.8594, -13.1970],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-12.2786,  -8.6579,  -3.3767,  -4.0684,  -7.9970,  -4.5758,  -7.6140,
        -11.7478,  -3.1496,  -4.4270,  -8.5944,  -5.9290,  -5.6457, -12.0743,
         -6.7990,  -2.0349, -11.6179,  -6.6361,  -3.3321,  -7.1415],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.3193,  -9.3345,  -4.3910,  -9.7863,  -4.9295,  -4.6391,  -5.6348,
        -10.5026,  -4.4824,  -6.3905,  -1.6651, -13.2785,  -5.8711,  -5.2685,
         -5.1465,  -3.5247,  -8.0202,  -4.8735,  -4.1215,  -6.5187],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -9.6572,  -5.0786,  -7.3986,  -3.4738, -22.9930,  -6.6650,  -3.3717,
         -3.0058,  -5.8674,  -5.2344,  -6.8791, -12.2630,  -4.2930,  -6.3053,
         -5.3905,  -4.2649, -10.0756, -21.7398,  -7.3163,  -2.7497],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.0666,  -6.8604,  -3.5230,  -4.9826, -16.9823,  -8.5627,  -3.0735,
         -4.8830,  -4.1332, -14.6247,  -3.3598,  -5.0091,  -1.7139,  -5.6525,
         -6.1505,  -5.9784,  -6.6658,  -4.0264,  -4.3483,  -8.5362],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.2306,  -5.6056, -10.9515, -11.4478,  -4.3654,  -3.6984,  -4.7331,
         -5.3827,  -7.2972, -12.8915,  -4.6895,  -2.5261,  -3.2308,  -5.3350,
         -6.0209, -12.3782,  -3.2861,  -4.1125,  -3.3622,  -7.1503],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.1576, -27.1202,  -6.7722,  -3.0302,  -3.9525,  -3.4699,  -5.2633,
         -5.3332,  -5.4603, -15.9566,  -4.8003,  -1.7976,  -3.4010,  -2.3454,
         -5.2374,  -6.2017, -21.1480,  -6.4677,  -5.9168,  -4.1725],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-20.5575,  -4.0282,  -4.3676,  -4.4814,  -7.2236,  -4.2860, -20.5711,
         -7.1762,  -3.4965,  -3.0410,  -3.3988,  -7.6374, -15.1110,  -7.9394,
         -8.5191,  -4.6960,  -4.9699,  -6.2641, -11.7213,  -4.6409],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.4306,  -4.0626,  -5.0261,  -4.5309,  -5.3327, -13.8087,  -4.3460,
         -3.9388,  -5.4793,  -4.4731,  -6.1198,  -9.2653,  -5.6110,  -2.9236,
         -3.6574,  -5.5279, -10.3097,  -4.3876,  -6.5101,  -2.5533],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.1767,  -4.2289,  -4.3770,  -5.2296,  -3.2767,  -5.7086,  -5.4918,
         -7.0206,  -4.8617,  -7.0728,  -3.3717,  -3.0823,  -4.6224,  -6.9468,
         -4.0066,  -4.0146,  -3.5869,  -7.1537, -15.9041,  -6.4605],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.3529,  -4.3241, -12.8597,  -6.1685,  -4.2738,  -4.5005,  -4.4898,
         -3.6255,  -5.9968,  -9.5942,  -6.5432,  -3.4545,  -4.8553,  -5.1797,
         -5.3395, -17.0692,  -5.8774,  -4.6889,  -4.9058,  -5.5882],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.4707,  -7.1802,  -5.0748, -12.0484,  -7.5591,  -5.0246,  -5.9900,
         -6.9420,  -4.6332,  -5.2622, -18.7042,  -6.1252,  -2.9333,  -5.5362,
         -7.7272,  -4.5396,  -6.2275,  -9.1006,  -4.7673,  -4.0821],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -9.9941,  -3.9491,  -6.3552, -12.4219, -10.3707,  -2.8059,  -4.2710,
         -6.9138,  -7.3686,  -3.1867,  -6.7850,  -3.3202,  -6.5534,  -7.3982,
         -9.2528,  -4.3986,  -4.5102, -10.0403, -17.2771,  -8.7452],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.1071,  -3.9546,  -5.7378,  -6.8371,  -9.4700,  -5.1915,  -3.3023,
         -3.3536,  -5.9476,  -4.3329,  -5.9065, -11.9760, -12.6772,  -4.8246,
         -2.7512,  -3.9926,  -5.7052, -19.1900,  -5.7223,  -3.5010],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.4861, -19.9599,  -5.0610,  -7.1273,  -4.8878,  -8.3960,  -4.4934,
        -20.6466,  -8.6721,  -3.3519,  -8.3636,  -6.6745,  -4.6801,  -5.7780,
        -10.5863,  -4.1714,  -3.9076,  -2.4534,  -4.3791,  -5.2378],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.3530,  -5.0849,  -4.1994,  -7.7498, -16.7212,  -4.3410,  -5.2196,
         -3.3348,  -5.6134,  -7.9832, -20.0926,  -5.0471,  -4.4905,  -5.0744,
         -3.3854,  -7.2621,  -6.4762,  -4.5784,  -7.4290,  -3.8483],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-17.9316,  -4.9808,  -4.0267,  -5.1748,  -3.1629,  -7.8939,  -9.6694,
         -4.9546,  -5.0168,  -4.9120,  -4.3159,  -6.9577, -25.8948,  -4.5935,
         -2.9148,  -4.3495,  -4.9048,  -4.4098,  -5.7884, -12.5085],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -7.0161,  -3.9844,  -2.5340,  -4.9084,  -4.8134,  -5.6528,  -2.9473,
         -6.6483,  -3.9350,  -6.8614, -27.7379,  -6.1791,  -3.5830,  -2.9915,
         -5.3778,  -5.3164, -19.0382,  -4.1516,  -4.2203,  -6.1329],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -8.2157,  -4.3553,  -2.2631,  -8.9624, -22.4119,  -4.8564,  -3.7731,
         -5.1749,  -4.6599,  -4.3463,  -7.9291,  -6.4937,  -6.0925,  -4.8982,
         -5.8477,  -5.6683, -16.3381,  -6.3447,  -5.0015,  -3.9015],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -2.7559,  -5.1534,  -5.1478, -20.6723,  -6.7527,  -5.6971,  -4.4160,
         -5.1155, -31.0784,  -3.8217,  -9.9990,  -3.7124,  -3.9756,  -4.9507,
         -5.6665,  -4.2302,  -4.4312,  -4.4697,  -4.1721,  -2.2969],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-11.4361,  -6.2507,  -5.8982,  -4.7775,  -2.1076,  -6.6333,  -6.3972,
         -6.2384,  -5.9978,  -3.8470,  -4.4946,  -9.2560,  -4.9407,  -4.0047,
         -5.2830,  -2.8358, -21.0837,  -5.3729,  -4.2666,  -6.5560],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.7485,  -9.2351,  -3.7677,  -6.9936,  -2.3215, -13.7372,  -6.7719,
         -3.2013,  -6.6516,  -6.4265,  -4.7666, -12.0380, -10.8553,  -6.0795,
         -4.2682,  -3.3847,  -4.5124,  -3.4732, -16.2906,  -6.5918],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-10.1078,  -4.0330,  -5.8738,  -3.5869,  -5.5847,  -7.6495, -11.2727,
         -6.9561,  -4.4010,  -4.3589,  -3.2436,  -3.4144,  -2.5654,  -6.7606,
         -3.6928,  -9.9004,  -6.5688,  -3.8059,  -6.9238,  -9.4644],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.5083,  -4.8389,  -4.2677,  -4.5196,  -4.3706,  -7.0497,  -3.7337,
         -3.7172,  -7.5978,  -2.1078,  -7.0238,  -4.9306,  -3.5437,  -6.6020,
        -11.1914,  -4.8238,  -4.9350,  -2.2186,  -4.6816, -11.6102],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.4562, -12.9291,  -5.7840,  -3.9964,  -3.1333,  -5.4174,  -5.6760,
         -6.4009, -14.1317,  -5.8782,  -5.8535,  -4.1887,  -8.3166,  -4.2922,
        -17.1528,  -3.7199,  -3.6665,  -2.4130,  -4.8036,  -4.6438],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-13.6910,  -3.4698,  -4.4259,  -7.2019,  -8.5976,  -5.9140, -21.0326,
         -6.0051,  -3.7565,  -3.6982,  -6.5158,  -5.8723,  -9.7566, -11.6113,
         -5.9261,  -5.2198,  -7.5603,  -8.1017,  -3.9086, -25.4868],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.0004,  -3.7287,  -5.1855,  -6.2535,  -6.8745,  -3.7021,  -4.7605,
        -14.1317,  -3.7265,  -3.5516,  -6.3436,  -3.3554,  -9.0730,  -8.6765,
         -6.4528,  -4.9489,  -4.5086,  -6.1063,  -4.2751,  -3.5689],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-11.0575,  -5.3842,  -4.2086,  -3.7604,  -5.6605,  -5.1049,  -7.1859,
        -20.7968,  -4.9993,  -4.3186,  -4.4698,  -8.9667,  -3.9631, -14.6550,
         -4.8859,  -3.6108,  -1.2690,  -5.3683, -32.7069,  -3.6108],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.2272,  -4.3102, -15.3651,  -9.7844,  -4.9129,  -6.5432,  -6.5811,
         -4.2439,  -6.3865, -16.5426,  -7.1796,  -4.0334,  -4.0560,  -7.6810,
         -9.5677,  -5.4074, -14.2728,  -6.2026,  -3.9217,  -6.0427],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.0428,  -5.1092,  -8.4676, -17.1690,  -3.6654,  -3.2714,  -4.1582,
         -6.8549,  -4.7480,  -6.8614, -14.3110,  -5.3109,  -3.9289,  -3.9656,
         -7.3197,  -4.0982, -15.5623,  -6.5761,  -4.1679,  -5.9579],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -7.0105,  -3.7299, -23.8740,  -7.9002,  -2.3023,  -2.3048,  -4.5440,
         -5.0218,  -6.2739, -14.7992,  -3.4099,  -9.8034,  -3.9064,  -6.5515,
         -3.8400, -15.7193,  -7.0250,  -5.5501,  -4.1044,  -7.4679],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.2580, -10.8081,  -9.1491,  -2.1524,  -3.2208,  -4.9170,  -7.3877,
         -4.0475,  -1.7756,  -6.1055,  -3.3211, -10.8551,  -7.5282,  -4.1260,
         -5.0910,  -3.7720, -11.5008,  -8.5472,  -9.5152, -17.8230],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.5325,  -6.3597,  -3.8224,  -5.0830,  -5.2663,  -6.3871,  -4.5145,
        -12.4144,  -6.0662,  -4.3369,  -4.4209,  -7.1176,  -4.9456,  -4.9121,
        -14.0970,  -6.1139,  -4.4901,  -4.7889,  -3.8548,  -7.8551],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-20.1255,  -5.7206,  -3.0475,  -3.0864,  -5.2309,  -5.1383,  -7.5430,
        -13.3268,  -5.1220,  -4.2905,  -3.3299,  -5.4320,  -4.0016, -22.3318,
         -5.2492,  -5.0309,  -5.0602,  -4.5669,  -9.4102, -17.7018],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -7.5332,  -5.9182,  -1.7371, -12.2656, -15.3268,  -5.3096,  -3.5370,
         -4.9671,  -4.2855,  -5.4511,  -3.7035,  -2.5880,  -6.2140,  -1.5045,
        -17.6822,  -5.0700,  -2.9833,  -5.9314,  -5.5561,  -2.7831],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.5036, -22.7811,  -5.7300,  -3.4994,  -3.2135,  -4.4510,  -4.5158,
        -17.4293,  -5.8271,  -3.8962,  -5.7125,  -5.6352,  -9.3918, -17.7562,
         -9.7610,  -3.3270,  -3.9453,  -5.4073,  -4.6771, -33.4151],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.6430,  -4.5134, -24.6250,  -4.7245,  -4.4647,  -3.7036,  -6.0426,
         -5.7289, -11.5659,  -5.1274,  -4.1109,  -4.1704,  -4.5072,  -5.4296,
        -18.1217,  -5.5063,  -3.3267,  -4.9719,  -4.7609,  -4.2486],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.5041,  -4.0868,  -7.2426,  -9.6628,  -4.0292,  -4.2634,  -6.0303,
         -5.5242,  -4.5854, -19.3084,  -6.4995,  -5.1934,  -4.0120,  -7.3850,
         -4.5660,  -6.3009, -17.9747,  -6.5729,  -4.3281,  -6.8822],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.3392,  -8.4723, -11.9087,  -6.8737,  -5.0389,  -1.7862,  -4.2813,
         -3.9027,  -5.5325,  -6.3597,  -3.8224,  -5.0830,  -5.2663,  -6.3871,
         -4.5145, -12.4144,  -6.0662,  -4.3369,  -4.4209,  -7.1176],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.7237,  -5.8244, -14.9110,  -5.0737,  -4.3874,  -3.9932,  -4.8051,
         -7.0571, -12.8744,  -4.7241,  -4.9641,  -3.4461,  -6.2700,  -4.9000,
        -14.7155, -11.0546,  -6.8553,  -3.9892,  -3.8141,  -4.2304],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.2406,  -3.2674,  -2.4972,  -4.4328,  -5.2995, -25.2942,  -3.6335,
         -3.7461,  -3.9938,  -5.4465,  -3.7540, -10.4709,  -8.9904,  -6.1364,
         -6.7398,  -4.4776,  -6.8437,  -6.1996, -14.5621,  -8.3336],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.8494,  -4.2549,  -4.5436,  -7.9611,  -6.6040,  -9.7846, -13.7978,
         -3.1287,  -2.9793,  -4.1986,  -5.0019,  -3.9738,  -6.1273,  -3.3959,
        -25.9651, -14.9429,  -7.0288,  -5.1331,  -3.1991,  -8.4562],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.3317, -10.0768,  -4.6737, -13.8719,  -5.3173,  -3.2346,  -3.9258,
         -7.2946,  -5.8385,  -5.0522, -19.2022,  -5.3714,  -3.7307,  -2.5245,
         -5.6737,  -5.5313,  -7.4434, -16.9562,  -4.6373,  -4.2213],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.3506,  -7.1595,  -5.8962,  -3.4560,  -9.9706, -10.8357,  -5.1128,
         -2.2570,  -2.9635,  -6.5690,  -5.0314,  -3.5885, -17.4082,  -4.7874,
         -8.7414,  -5.6771,  -2.4582, -10.8141, -11.5083,  -5.8406],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.8459,  -7.0909,  -8.1364,  -2.4179,  -4.9337, -15.7629,  -8.3162,
         -3.8137,  -6.6666,  -5.6482,  -5.6877, -18.5885,  -6.5105,  -5.8734,
         -2.9876,  -7.4780,  -5.9230,  -5.7207, -20.1189,  -6.5247],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.1273,  -6.1282,  -6.7689,  -3.1692,  -7.1337, -11.5710,  -8.9776,
         -5.7282,  -2.9712,  -6.6490,  -5.8691,  -6.6070,  -4.6381,  -3.7814,
         -7.1709,  -5.1648,  -6.7747, -12.6118,  -7.1575,  -3.2038],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -8.9365,  -9.0627,  -6.6221,  -5.3135,  -4.7355,  -4.4140,  -6.3131,
         -9.1856, -16.5712,  -5.1483,  -5.6376,  -5.7975,  -3.9433,  -4.2570,
        -14.4137,  -4.5882,  -5.7443,  -4.5682,  -3.5959,  -7.5193],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.3239,  -4.3656,  -5.1255,  -3.4277,  -6.5913,  -2.1295, -27.6491,
         -6.6086,  -3.3598,  -4.0952,  -5.6061,  -5.6288,  -4.4482, -21.5661,
         -4.8465,  -7.5365,  -5.3303,  -3.5504,  -4.1935, -18.8032],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.5454,  -6.1236,  -5.0813,  -5.7509, -16.9823,  -5.7661,  -4.5896,
         -8.8549,  -7.1114,  -2.1572, -32.4671,  -6.8348,  -2.0421,  -4.0130,
         -4.7437,  -5.2714,  -5.9081,  -7.6520,  -4.8419,  -6.3228],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.9507, -12.3805,  -7.5380,  -4.4625,  -5.1538,  -8.0399,  -4.5240,
        -10.2010, -29.9892,  -5.5538,  -4.9414,  -5.1225,  -6.1392,  -4.0663,
        -23.7649,  -5.3584,  -3.8606,  -5.1728,  -5.6691,  -4.6406],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-11.4321,  -5.6097,  -4.5025,  -3.4322,  -5.3130, -24.3719,  -5.5989,
         -3.5916,  -2.2669,  -3.9541,  -7.1771, -13.6299,  -5.2920,  -5.6022,
         -5.5936,  -3.1538,  -9.4720, -23.1600,  -3.8697,  -5.5026],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-21.4695,  -4.3507,  -3.1031,  -3.6933,  -5.7439,  -3.5923, -10.4484,
        -24.3702,  -4.5347,  -4.8685,  -5.8740,  -4.0105,  -5.8283, -19.9548,
         -7.2508,  -9.1663,  -3.5567,  -7.9593,  -5.6200,  -6.3725],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.9941,  -2.3385,  -4.8415,  -4.9978,  -7.2245,  -4.5225,  -4.9972,
         -3.3262,  -8.6253,  -4.5387,  -5.1284,  -5.0982,  -5.5815,  -4.3169,
        -23.1002,  -4.3618,  -2.1857,  -5.4060,  -4.6062,  -4.4785],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.0569, -10.4862, -17.0049,  -5.8374,  -4.1723,  -4.6296,  -5.5975,
         -7.4784, -30.0959,  -4.4105,  -4.3114,  -4.1418,  -3.9885,  -8.1818,
        -19.8535,  -4.9933,  -5.0266,  -2.8193,  -6.6653,  -4.1975],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.4769,  -5.1492, -12.8925,  -2.5440,  -4.0174,  -2.7616, -10.7261,
         -5.0518,  -4.4148,  -3.6692,  -7.3465,  -4.6412,  -8.6992, -16.7157,
         -6.0922,  -2.8163,  -1.3467,  -4.0513,  -5.8502, -22.3938],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-10.2283,  -3.6436,  -8.2491,  -2.9435, -12.1690,  -5.5205,  -3.5410,
         -4.2978,  -4.1111,  -5.5098,  -9.3901,  -3.1417,  -4.1816,  -4.5928,
         -4.5094,  -5.7363,  -4.5294, -13.3788,  -5.3479,  -4.4685],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -9.0229,  -5.3431,  -3.5822,  -3.5538,  -3.0147,  -5.1666,  -2.4551,
         -4.2708,  -2.6229,  -7.9265,  -5.4169,  -5.7225,  -4.6175,  -3.9451,
         -5.8376, -15.0433, -10.7671,  -8.0577,  -3.3423,  -5.6819],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -2.6810,  -9.9469, -11.6800,  -3.1072, -21.1361,  -7.3544,  -3.5392,
         -1.8220, -10.0026, -20.1043,  -4.2559,  -3.9300,  -2.5970, -25.5908,
         -5.8653,  -4.2654,  -4.8102,  -3.9730,  -3.6230,  -9.7122],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -2.7916,  -7.2434, -16.4631,  -5.2028,  -4.2909,  -6.9121,  -3.6790,
        -12.4390,  -5.0187, -10.9496,  -8.2222,  -3.6708,  -8.7569,  -5.9702,
         -5.6355, -10.8386, -11.2324,  -4.0297,  -5.9245,  -4.7122],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-15.1878,  -4.5392,  -3.1782,  -4.3953,  -5.8927,  -4.2220,  -4.9030,
        -16.3169,  -4.4009,  -4.4510,  -5.5972,  -3.1336, -10.2681,  -9.0373,
         -5.8558,  -6.3610,  -2.9816,  -4.5243,  -3.6977, -12.6679],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.5716,  -4.9723,  -5.1625,  -7.4041,  -7.2076,  -4.6745,  -3.3422,
         -2.7864, -11.7201, -13.8423, -12.6142,  -5.3810,  -8.4986,  -5.5104,
         -6.2845, -14.2336,  -5.5237,  -3.4943,  -4.1082,  -5.5612],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-10.4290,  -6.4963,  -5.2429,  -6.0737,  -5.5858,  -5.7516, -19.0255,
         -6.8480,  -3.7904,  -3.8242,  -7.1713,  -7.5901,  -4.6276, -15.2513,
         -5.9144,  -2.7473,  -4.4805,  -9.3584,  -4.7467,  -5.5813],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.0500,  -8.9283, -12.6016,  -3.1726,  -1.9842,  -4.7425,  -3.9930,
         -7.0044,  -3.6909,  -3.3388,  -4.6490,  -2.1739, -20.6508, -12.0926,
         -7.0777,  -7.1379,  -4.2317,  -7.4898,  -6.5994,  -6.0992],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-11.7771,  -2.0670,  -3.7169,  -4.1407,  -5.6034,  -3.8867, -21.3296,
         -6.3682,  -3.9257,  -3.8368,  -4.2521,  -5.2287, -24.5995,  -4.1241,
         -4.4153,  -3.6973,  -7.2351,  -4.7721, -12.9942,  -3.4034],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.0636,  -7.9273,  -5.4004,  -3.5902,  -6.3655,  -3.9895,  -5.4965,
         -3.4757,  -5.9914,  -6.4725,  -2.3502,  -7.9005,  -4.9927, -26.4827,
         -6.0751,  -3.3317,  -2.8722,  -9.8590,  -5.4552, -10.6278],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.1438,  -3.7413,  -4.1561,  -8.7759, -10.4906,  -5.3400,  -7.2123,
         -6.3099,  -5.5238,  -6.2829,  -5.0817,  -4.5793,  -5.2966,  -3.5050,
         -7.3960,  -3.9466,  -8.0386,  -9.7270,  -4.1366,  -5.1716],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.2899,  -3.9679,  -3.5718,  -7.4340,  -5.1850,  -8.8197, -10.0103,
         -6.0284,  -4.3258,  -3.6075,  -6.1064,  -5.1024,  -8.0476, -15.0154,
         -5.1300,  -3.7950,  -4.9703,  -6.7978,  -4.0152,  -7.6278],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.7163,  -7.4576,  -4.4369, -13.9109,  -6.0221,  -3.1911,  -4.7683,
         -6.2491,  -4.6538, -21.8285,  -5.8470,  -4.4766,  -3.6559,  -8.2514,
        -12.8027,  -3.9291,  -4.8038,  -4.3312, -21.2761,  -6.8816],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.4712,  -5.2633,  -4.0574,  -5.7484, -11.3031,  -4.3259,  -4.4523,
         -3.4551,  -5.6015,  -7.1771, -17.1056,  -4.6486,  -4.1232,  -4.7377,
         -3.5912,  -4.9841,  -8.8238,  -5.7573,  -4.9781,  -3.6517],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.8252,  -5.8124,  -4.1798,  -6.5226,  -4.5476,  -4.8182,  -7.1391,
         -6.4485,  -5.3879,  -3.2710,  -3.5569,  -3.1540,  -5.2719,  -3.7785,
         -7.4625,  -5.2126,  -3.2115, -11.6726,  -7.6880,  -7.7906],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -9.2181,  -2.5629,  -7.9959,  -6.1077,  -6.2997,  -6.2567, -11.3614,
         -6.1990,  -4.2710,  -4.0702,  -5.0628,  -4.7454,  -6.9979, -17.7996,
         -6.5818,  -3.3554,  -3.3934,  -4.2826,  -4.3735, -26.2658],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-11.4042,  -2.5810, -14.5248,  -4.8695,  -2.5864,  -3.9543,  -4.2696,
         -7.0159,  -4.6044,  -6.7201, -13.0016,  -8.7541,  -4.8171,  -7.2009,
         -5.1771,  -5.6106, -18.4206,  -6.6908,  -3.4238,  -3.5322],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-17.2501,  -8.4407,  -3.8502,  -3.8469,  -8.0939,  -6.9590,  -7.5592,
        -20.5046,  -7.9114,  -5.3220,  -4.6667,  -3.6250,  -5.2795, -10.1037,
         -5.3208,  -5.7772,  -3.3792,  -5.8838,  -4.4719,  -4.7847],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.6811, -14.7759,  -5.8416,  -3.8300,  -4.0320,  -6.8807,  -5.9666,
         -6.2269, -12.1485,  -5.6020,  -2.9090,  -5.6643,  -3.9736,  -5.3697,
        -20.0711,  -5.3957,  -7.6938,  -6.3648,  -6.4912,  -4.4645],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.6689,  -5.4098,  -3.1956,  -4.1824, -11.5802,  -6.1461,  -4.1979,
         -4.9405,  -4.4612,  -3.7131, -19.7435,  -3.7808,  -9.3759,  -4.5268,
         -3.3461,  -8.2022, -10.1352,  -6.9860,  -6.6845,  -4.0022],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.5229,  -7.5416, -10.1638,  -3.7889,  -6.0195,  -4.8356,  -4.8610,
         -4.7370, -14.2862,  -4.3330,  -3.8840,  -3.4131,  -6.0808,  -6.0224,
         -8.6630,  -3.6117, -14.8513,  -6.4370,  -4.1097,  -2.6282],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -8.2720,  -4.5678,  -4.0570,  -8.8525, -12.2936,  -6.4228,  -4.2817,
         -3.0165,  -5.7132,  -5.1536,  -7.4844, -12.7213,  -5.5681,  -6.6400,
         -4.9933,  -4.3802,  -8.6220, -10.6614,  -4.8995,  -2.8630],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-24.1397,  -6.1568,  -5.2151,  -5.8628,  -7.6078,  -4.3136, -14.5528,
         -9.1235,  -6.9897,  -7.4591,  -4.4795, -10.1639, -21.6171,  -8.4689,
         -3.9486,  -5.3685,  -5.9426,  -4.0486, -11.1165,  -9.7952],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.9714, -17.3793,  -5.0477,  -3.4921,  -5.2769,  -6.1833,  -4.3876,
        -11.7347,  -2.0539, -23.1059,  -3.1118,  -3.4017,  -1.1739,  -4.6298,
         -7.7054,  -5.6255,  -4.4225, -18.9029,  -8.3233,  -5.4245],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -7.1973,  -3.3666,  -7.4644,  -3.9285,  -4.5831,  -3.3158,  -6.7304,
         -4.0369,  -4.1807,  -2.9877,  -3.1717, -15.7611,  -4.9224, -12.5347,
         -5.6193,  -5.5052,  -5.0357,  -5.9680,  -9.9451,  -8.3217],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.7191,  -5.3672,  -8.0915,  -7.4253,  -2.5006,  -4.8528,  -4.1327,
        -29.1639,  -6.0647,  -4.1435,  -4.8046,  -2.2365,  -7.2547,  -4.9477,
         -5.0079,  -8.9813,  -5.5093,  -6.6134,  -3.8827,  -6.4236],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.2601,  -4.1421,  -2.7012,  -5.5171,  -2.6725, -10.6922,  -5.8367,
         -4.5501,  -6.8916,  -2.4249, -14.3419,  -6.3782,  -5.7689,  -3.9195,
         -3.3193,  -4.7767,  -3.9550,  -3.6181,  -5.5825,  -2.0324],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.9167,  -3.9055,  -7.0352,  -6.2371,  -9.7840, -12.2152,  -5.0025,
         -3.3521,  -3.8416,  -4.0538,  -5.1485,  -5.5163, -16.3638,  -5.2001,
         -4.3343,  -3.4435,  -2.7690,  -7.7956, -15.0281,  -7.3164],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -7.0363, -13.3204,  -4.5774,  -3.9901,  -3.7480,  -4.6486,  -7.9059,
        -12.3183,  -5.8296,  -5.1102,  -4.3175,  -6.3866,  -5.3810, -29.8682,
         -4.5673,  -3.8777,  -3.7290,  -4.7422,  -5.4004,  -4.8265],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-4.0115, -4.8926, -6.2876, -5.2612, -1.8740, -9.0444, -5.9456, -4.7650,
        -5.7532, -3.3896, -8.9565, -8.6001, -6.5594, -3.8615, -4.3723, -3.4083,
        -6.2312, -5.6540, -5.7276, -4.8587], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -4.7430, -14.1689, -20.9791,  -4.6687,  -3.5403,  -6.3197,  -9.1292,
         -5.2755,  -5.2629,  -2.9077, -14.4660,  -5.6307,  -3.6650,  -6.2509,
         -2.5022, -15.1087,  -5.7960,  -3.0961,  -5.4177,  -4.4027],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.1972,  -5.1383,  -3.4367,  -9.3969,  -1.6332,  -4.0868,  -9.2366,
         -3.3264,  -6.1759,  -5.7981,  -5.2771,  -8.5422, -13.4156,  -4.2791,
         -4.9068,  -3.2515,  -5.9403,  -4.5258,  -8.6220,  -7.4226],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.5127,  -3.6147,  -8.0759,  -6.0535,  -4.4246, -23.9701,  -5.9051,
         -3.5099,  -6.3826,  -8.1089,  -4.3930,  -5.2248, -14.7961,  -4.6224,
         -3.6058,  -5.4929,  -9.0640,  -3.1218, -22.9755,  -7.3895],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-16.2435,  -6.3147,  -4.8554,  -2.8276,  -5.9298,  -5.8519,  -5.4191,
         -4.1163,  -4.6030, -14.4911,  -4.8524,  -5.6894,  -7.2896,  -2.7611,
         -5.4086,  -6.6349,  -5.1305,  -4.2549,  -4.9155,  -8.7617],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-21.5611,  -5.9233,  -3.6987,  -2.8234,  -4.0770,  -7.6620, -13.7568,
         -4.6156,  -7.9122,  -3.8484,  -6.1055,  -5.2538, -29.4790,  -4.3047,
         -3.3218,  -3.8824,  -4.3750,  -7.9635,  -8.8894, -16.4070],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -2.0931,  -0.6536, -16.0488, -33.5996,  -3.4354,  -3.6569,  -3.7721,
         -5.0400,  -2.3439, -11.6309,  -4.4822,  -3.9556,  -4.0049,  -5.1149,
         -4.2313,  -5.9172,  -3.1438,  -6.7279,  -4.5940, -13.5487],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.5717,  -5.5147,  -6.2921,  -5.5396,  -3.5888,  -4.4532,  -3.0753,
         -5.5814,  -4.4751,  -4.7462,  -4.7472,  -5.6475,  -3.8078, -13.4166,
         -5.7977,  -3.9079,  -4.0171,  -6.4236,  -2.9707,  -9.2046],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.3306,  -6.0102,  -6.6937,  -5.1700, -13.9438,  -5.0015,  -4.6802,
         -3.7347,  -4.0090,  -7.3017,  -7.9701, -20.5441,  -6.5276,  -3.6458,
         -3.4966,  -5.6773,  -4.7596, -19.0594,  -3.6053,  -4.9279],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.2050,  -5.7367,  -4.3535, -12.5048,  -8.6376,  -3.0154,  -4.1465,
         -5.8106,  -7.3722,  -5.2459, -23.6773,  -4.8836,  -3.2860,  -4.3564,
         -5.1760,  -6.7685,  -4.3453,  -2.8964, -13.0448,  -7.1546],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.7925,  -3.9116,  -8.8593,  -4.8115,  -7.4223,  -6.8049,  -6.3692,
         -5.5941,  -5.5257, -11.0195,  -5.4376,  -4.9162, -10.7132,  -3.3438,
         -7.8535,  -6.2957,  -5.3637,  -3.3049,  -4.6399,  -3.1238],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-10.1460,  -8.4016,  -4.4169,  -3.5674,  -5.2379,  -6.7140,  -4.1882,
        -15.6894,  -6.2093,  -4.7686,  -4.9058,  -6.2822,  -4.5708,  -8.3377,
        -18.5724,  -7.1487,  -4.5204,  -4.4384,  -7.1727,  -3.4732],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -2.7893,  -4.5386,  -1.9134, -13.4268,  -5.9578,  -4.7598,  -4.6114,
         -4.2886,  -4.4045, -15.0262,  -7.5339,  -5.0962,  -3.2051,  -4.0045,
         -3.6586,  -8.9188,  -8.2062,  -4.6091,  -6.0942,  -4.0667],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.5210,  -9.8524, -16.6807,  -5.5425,  -4.3043,  -5.7022,  -2.0980,
         -5.8317,  -7.1512, -11.1822,  -3.4360,  -4.5712,  -4.1719,  -9.6135,
         -4.0607,  -6.3404,  -7.0578,  -4.2345,  -5.1227,  -3.7271],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -7.9987,  -5.9133, -17.1743,  -5.4961,  -3.8160,  -3.2580,  -5.4140,
         -4.7810, -11.6062,  -4.8393,  -3.4547,  -4.1402,  -7.2904,  -5.0734,
         -4.4525, -23.1925,  -4.7989,  -3.0349,  -3.0263,  -7.0864],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.1349,  -4.8035,  -4.8863, -15.4862,  -5.5102,  -3.0854,  -2.4250,
         -6.1292,  -5.2271,  -6.4560, -14.3234,  -3.6091,  -4.2374,  -3.2142,
         -7.4508,  -4.6843,  -9.4569, -20.1608,  -7.0927,  -3.3646],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-16.5826,  -3.8367,  -4.1659,  -4.7469,  -3.9980,  -8.7340, -13.0103,
         -6.3681,  -6.7882,  -3.7661,  -4.9394,  -9.4087, -11.5352,  -5.7630,
         -3.9425,  -3.4661,  -9.6657,  -5.6733, -23.7987,  -5.3249],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.5677,  -4.8276, -14.3845,  -4.8407,  -6.1880,  -4.3139,  -3.3576,
         -5.0384, -18.7691,  -5.0862,  -3.8296,  -2.1469,  -3.5939, -14.5269,
        -10.9663,  -3.6334,  -7.7249,  -5.1361,  -3.1912,  -4.4031],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.5447,  -4.1666, -13.9374,  -5.7461,  -4.6831,  -3.1839,  -4.5067,
         -5.7586,  -3.4954, -14.2346,  -4.6400,  -3.3479,  -5.5785,  -4.6909,
         -5.6446,  -4.1754,  -5.6692, -13.3966,  -5.4969,  -4.0386],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.5617,  -2.3004,  -1.6464,   0.2047,  -3.0735, -11.9810,  -4.5895,
         -3.7986,  -1.9196,  -4.3867, -16.5294,  -4.3798,  -3.0231,  -2.9257,
         -5.4245,  -4.5878,  -5.7252, -12.7405,  -4.1067,  -4.7214],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.2319,  -3.1465,  -3.8138,  -2.8607,  -5.2437,  -2.6230,  -3.0464,
         -0.7611,  -4.4078,  -6.0018,  -3.1119,  -3.5473,  -3.6837,  -4.6609,
        -11.6720,  -5.4308,  -3.4295,  -1.6249,  -4.0494,  -3.3453],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-4.5604, -4.0408, -5.6609, -3.2411, -5.3775, -2.0272, -5.0573, -5.3984,
        -3.7837, -4.1685, -3.0507, -4.1002, -7.8665, -5.0509, -3.9856, -4.8691,
        -4.3327, -4.4738, -2.1866, -2.7695], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -4.3396,  -3.2197,  -6.3981, -10.4502,  -4.9547,  -4.1568,  -4.3657,
         -3.4740,  -5.1965,  -6.3786,  -5.2525,  -3.7983,  -3.2895,  -3.3722,
         -3.0554, -13.3601,  -5.2821,  -5.5048,  -3.5179,  -3.4296],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.1398,  -4.9799,  -3.2969,  -8.0930,  -3.7711,  -4.5827,  -3.0826,
         -8.9470,  -5.6422,  -2.2441,  -4.5333,  -4.7716,  -4.2758,  -6.6649,
        -13.6156,  -4.7076,  -4.2727,  -3.4018,  -4.8872,  -4.4985],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.5864, -16.4951,  -2.5365,  -3.1782,  -3.8436,  -5.9966,  -7.9701,
         -4.4662,  -3.7848,  -5.6585,  -3.7513,  -5.6131,  -7.4678,  -4.5883,
         -5.4617,  -3.2255,  -3.4838,  -3.6265, -10.9742,  -4.7027],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-5.3610, -6.9490, -3.3172, -2.8019, -2.7592, -4.8319, -9.8988, -5.4597,
        -6.3377, -4.1394, -2.6673, -4.6838, -7.6683, -4.9890, -4.2039, -4.7251,
        -2.9916, -5.6670, -9.8047, -4.0790], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -3.7286,  -3.0704, -12.2752,  -4.2126,  -4.0100,  -1.6915,  -2.3369,
         -4.4962,  -9.7374,  -5.8435,  -3.8962,  -3.8273,  -3.4088,  -5.0936,
        -12.1124,  -6.8871,  -3.2329,  -2.6201,  -4.6446,  -4.3416],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.0687,  -3.8363,  -3.0642, -10.3486,  -3.9882,  -3.3757,  -2.5080,
         -3.5573,  -6.5559,  -7.6244,  -7.6501,  -4.0932,  -2.4322,  -4.2475,
         -3.4612,  -8.4946,  -3.7723,  -4.8896,  -2.5678,  -3.6836],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.2845,  -4.3629,  -2.5081,  -8.6813,  -7.9155,  -3.0055,  -2.5928,
         -6.9324,  -4.6842,  -2.9658, -10.6055,  -5.0544,  -5.1088,  -3.6839,
         -6.3531,  -3.7721,  -8.4884,  -6.4561,  -4.2223,  -3.3660],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.7800,  -3.9116,  -2.5908,  -5.5658,  -4.3615,  -2.8394,  -2.0032,
         -3.4323,  -4.1307, -13.0161,  -3.7042,  -3.6277,  -4.3542,  -3.0549,
         -3.8749,  -8.6324,  -7.1802,  -3.7998,  -3.1577,  -7.6272],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -7.1487,  -9.3763,  -5.7461,  -2.9318,  -4.7347,  -5.0498,  -7.0899,
         -8.6117,  -3.6855,  -3.5762,  -0.9411,  -3.6894,  -4.1872,  -3.2753,
         -2.6229,  -2.5095,  -4.7092, -12.0026,  -5.0155,  -6.2529],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -2.9707,  -5.7543,  -3.9746,  -4.9704,  -4.5854,  -6.5629,  -3.7365,
         -1.8065,  -4.0607,  -1.2850,  -5.3054,  -4.1675,  -3.5214,  -3.6105,
         -3.7307,  -4.2456, -10.9466,  -4.3460,  -4.0451,  -3.4609],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.4903,  -5.1634,  -3.5351,  -4.5139,  -5.0711,  -2.8725,  -4.9205,
         -1.4807,  -6.4866,  -3.3243,  -3.6796,  -2.8062,  -4.0645,  -1.9867,
         -3.8417,  -4.3568, -26.5797, -20.1728,  -6.5109,  -5.4843],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-18.6639,  -4.9412,  -2.9233,  -4.3918,  -7.2093,  -3.9270,  -6.3981,
        -16.8274,  -7.5746,  -2.2166,  -3.5488,  -4.5481,  -4.7473, -14.1399,
         -3.9047,  -3.0163,  -2.3810,  -3.8694,  -5.1246,  -3.5391],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -2.0351,  -6.3634,  -6.6263,  -2.5750,  -3.2658,  -3.0301,  -4.2006,
         -7.6579,  -6.6737,  -3.6438,  -1.0904,  -1.7055,  -6.3698, -11.9124,
         -4.5748,  -6.2252,  -2.9422,  -3.7158,  -4.9385,  -5.1875],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-2.4721, -5.4199, -5.0175, -4.9589, -6.4058, -4.3786, -5.0433, -2.8807,
        -3.5662, -4.5507, -6.9094, -3.8706, -3.9615, -2.2293, -4.7573, -4.2562,
        -5.5124, -9.2516, -5.0061, -5.1204], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -2.8179,  -2.1106,  -4.7945,  -4.6172,  -5.8152, -10.3883,  -5.2060,
         -3.5775,  -4.1676,  -4.6235,  -3.1779, -10.0256,  -4.3616,  -2.2963,
         -3.5320,  -5.7487,  -8.4828,  -2.0854,  -4.0406,  -0.7806],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.3445,  -4.3316,  -3.0719, -12.9611,  -4.1904,  -4.5513,  -1.2984,
         -9.7712,  -2.5331,  -2.8231,  -5.3698,  -4.4245,  -3.7252,  -5.3211,
         -6.2512,  -5.6396,  -2.7735,  -2.6808,  -4.4894,  -3.8890],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.0334,  -3.6362,  -4.6166,  -4.0830, -16.6050,  -6.6299,  -2.6739,
         -2.8441,  -5.3946,  -4.9187,  -3.6165,  -9.4569,  -5.0328,  -3.6973,
         -4.2818,  -2.7709,  -7.6679,  -5.8430,  -4.2014,  -2.4065],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.0708,  -3.2457,  -6.9635,  -4.9331,  -3.0294,  -2.4667,  -3.9841,
         -3.2206, -13.6053,  -6.8666,  -2.5788,  -3.0114,  -4.0891,  -5.6055,
        -14.9240,  -3.6584,  -4.7904,  -3.9518,  -4.3345,  -6.9698],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.3354,  -4.9639,  -3.3626, -15.6180,  -4.2979,  -3.5014,  -2.6523,
         -5.3877,  -4.0888,  -5.0324, -17.5518,  -9.8357,  -2.6709,  -2.9373,
         -4.6053,  -4.2827,  -9.8313,  -5.6600,  -4.2098,  -5.1838],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-5.1506, -3.5822, -6.6029, -3.5953, -4.4762, -3.9495, -3.9529, -4.6411,
        -4.4943, -5.2238, -2.1843, -7.7137, -4.6748, -3.7907, -5.0081, -3.6443,
        -4.9131, -7.6825, -6.1381, -3.9776], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-7.7115, -4.1569, -3.4902, -3.2835, -4.4293, -4.1404, -9.9992, -5.1021,
        -4.0844, -4.2059, -3.5389, -7.5028, -7.1997, -4.6628, -3.0017, -4.4763,
        -9.3043, -5.5295, -3.0875, -4.0726], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -3.0711,  -5.1165,  -3.0708,  -6.5997,  -1.0160,  -8.5010,  -4.8926,
         -2.8511,  -4.2339,  -4.8996,  -4.2633,  -4.1246,  -5.9488,  -5.0657,
         -3.2017,  -2.8587,  -3.6017,  -7.8144, -10.2157,  -7.0950],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-5.4357, -9.7234, -1.5363, -3.2338, -2.8307, -6.9263, -5.4097, -2.4090,
        -3.1449, -3.1824, -3.6200, -7.5864, -7.4138, -2.3967, -2.8808, -2.7159,
        -4.5570, -9.0942, -5.1887, -3.1158], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -3.8480,  -6.6626,  -4.6596,  -3.4696,  -3.3360,  -0.5341, -22.0413,
         -5.5162,  -3.5610,  -5.3574,  -4.0520,  -7.9637,  -7.9735,  -4.9731,
         -3.4241,  -2.5658,  -4.8021, -11.3002,  -3.5706,  -4.5599],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.2808,  -4.3674,  -2.3227,  -1.7222,  -3.4740,  -4.6614,  -5.0555,
        -14.4319,  -4.9418,  -4.9100,  -3.9528,  -2.4027,  -8.0434,  -4.2233,
         -4.5110,  -3.1520,  -4.2840,  -4.7767,  -1.8360, -12.0326],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -2.6140,  -5.1757,  -6.1044,  -3.1540, -17.4168,  -5.3351,  -4.9077,
         -3.6704,  -3.8434,  -4.5433,  -9.8577,  -4.8266,  -3.3937,  -2.7307,
         -3.2320,  -4.0125,  -6.8282, -10.8311,  -4.5692,  -3.9740],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-2.7781, -4.9575, -2.5792, -4.8889, -4.5584, -3.1754, -4.2644, -2.8725,
        -6.0505, -6.3500, -5.4838, -5.1338, -3.4750, -4.0499, -5.3255, -7.3324,
        -3.9005, -4.2073, -3.4322, -3.5480], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-10.8362,  -6.6233,  -1.9016,  -2.9618,  -5.2561,  -4.1729,  -4.1590,
        -13.1384,  -3.1579,  -3.4739,  -3.5592,  -5.6452,  -5.1871,  -3.9956,
         -8.1056,  -4.4440,  -2.9773,  -3.1631,  -5.2801,  -4.6378],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.4463,  -5.0994, -10.0227,  -4.6877,  -3.8930,  -3.8141,  -4.7438,
         -3.7633,  -7.3940,  -7.9369,  -5.1384,  -3.6435,  -3.1627,  -4.6340,
         -5.4608, -12.2305,  -4.8290,  -2.9335,  -2.9876,  -5.7621],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.3094,  -4.3930,  -4.8211,  -7.1750, -10.6002,  -5.5782,  -2.1534,
         -3.0340,  -3.5710,  -4.2745,  -3.8946,  -7.9223,  -2.0139,  -3.4055,
         -2.7549,  -4.6660,  -4.3562,  -6.3995,  -5.0249,  -2.8696],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-14.8717,  -4.1282,  -5.6175,  -3.1550,  -2.8999,  -3.7457,  -4.5601,
         -6.5419,  -9.0343,  -2.7918,  -3.0583,  -1.9415,  -3.6052,  -5.0217,
         -3.9571,  -3.8906,  -7.0775,  -5.0021,  -3.9186,  -4.0938],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.9964,  -2.7625,  -2.9933,  -3.8390,  -6.2924,  -5.0382, -10.2434,
         -4.6660,  -3.3512,  -3.3448,  -5.6968,  -4.3445, -13.6587,  -6.0588,
         -3.3465,  -4.2203,  -2.7307,  -4.6971,  -5.4941,  -6.0300],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -2.1212,  -6.4435,  -3.5253,  -4.7352,  -3.9703, -10.2016,  -5.6305,
         -2.7665,  -4.4135,  -1.9169,  -5.6335,  -7.3035,  -3.8130,  -4.0756,
         -5.0733,  -5.7132,  -6.8922,  -3.2646,  -4.5495,  -2.1912],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.8836,  -2.3770,  -4.1384,  -0.8858,  -5.8705,  -4.7442,  -2.7454,
         -4.4038,  -3.8830,  -3.0357, -13.0301,  -5.6610,  -2.9634,  -4.3040,
         -3.3185,  -5.2018,  -2.4667,  -3.5023,  -1.0708,  -6.6755],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -2.5829,  -3.7366, -10.5123,  -5.6045,  -3.8444, -13.7419,  -5.7961,
         -2.7055,  -3.2588,  -5.0098,  -4.8416, -10.2191,  -5.0048,  -3.3934,
         -2.8669,  -4.4499,  -3.8262,  -5.4426,  -7.4277,  -3.9094],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.5909,  -4.3583,  -7.5127,  -4.8532,  -3.4945,  -3.4694,  -2.1442,
         -5.6892, -10.1185,  -5.7621,  -5.9317,  -3.8902,  -5.6941,  -4.5139,
         -3.9503,  -8.1080,  -6.2376,  -2.9139,  -2.8931,  -5.9074],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-2.8106, -3.6219, -4.2578, -2.4876, -2.7968, -0.8612, -5.4708, -6.2179,
        -4.0286, -4.2154, -2.9184, -7.5949, -6.6233, -6.3136, -5.5569, -3.1792,
        -8.1204, -8.6911, -3.2511, -4.8214], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -4.6887, -12.8893,  -6.4855,  -2.9821,  -2.6435,  -4.8994,  -3.2347,
         -7.9043,  -6.0085,  -3.2944,  -3.5728,  -5.6596,  -5.0990,  -4.2646,
         -8.1030,  -5.5105,  -3.1671,  -3.9656,  -4.2344,  -2.7074],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-16.1554,  -4.4636,  -3.7715,  -4.7650,  -4.7092,  -4.9405,  -7.9613,
         -5.9163,  -2.2955,  -4.4604,  -4.1309,  -5.2437,  -5.0032,  -6.5690,
         -3.3480,  -4.3269,  -3.6281,  -4.7111,  -4.5563, -12.8245],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-6.4184, -7.6555, -5.9878, -4.1069, -4.4208, -5.4074, -8.8599, -2.6737,
        -3.9633, -1.0029, -9.0683, -4.7122, -3.5064, -3.1912, -3.7888, -4.2629,
        -4.1944, -5.6932, -3.9253, -3.6419], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-6.3335, -3.7577, -4.9532, -8.7111, -4.7416, -3.8474, -2.5255, -4.9461,
        -3.1399, -6.1587, -7.5359, -3.1946, -3.3090, -6.2046, -4.8137, -8.4098,
        -8.1924, -4.7130, -3.6340, -3.6324], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -4.1486,  -6.2882,  -5.9765,  -3.5623,  -3.0491,  -5.2884,  -3.5306,
        -12.4070,  -3.7061,  -3.3541,  -2.9961,  -5.7507,  -4.5806,  -6.9229,
        -14.3980,  -4.8520,  -2.5358,  -2.4224,  -5.6831,  -5.8840],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-2.7406, -3.5611, -0.9097, -7.0881, -3.3919, -3.9669, -4.2606, -4.2280,
        -3.0880, -4.0238, -4.0880, -2.0518, -2.3171, -2.6436, -3.7101, -3.8091,
        -7.9916, -2.1511, -8.0638, -4.6197], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -4.0457, -12.0862,  -8.8186,  -3.3118,  -4.6537,  -5.2712,  -5.4718,
         -1.4198,  -3.0958,  -0.9482, -14.9350,  -5.1032,  -3.1109,  -3.4387,
         -3.2278,  -4.5564,  -7.3644,  -4.8266,  -2.8212,  -2.5590],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -9.2256,  -2.7760,  -2.9500,  -5.0564,  -4.5695,  -3.9188, -10.1568,
         -4.3566,  -3.8023,  -2.2054,  -4.7408,  -4.4923,  -5.0793, -11.4285,
         -5.1040,  -3.4434,  -2.2954,  -2.8033,  -7.8828,  -7.9979],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.1951,  -2.6266,  -5.7396,  -7.7157,  -3.3808,  -2.3773,  -5.2010,
         -7.6720,  -4.2009, -12.2091,  -5.0046,  -3.2945,  -2.5066,  -5.1790,
         -3.8397,  -4.4501,  -6.7593,  -9.2284,  -3.6172,  -4.2667],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-0.8786, -4.1386, -4.5784, -2.4072, -3.3034, -3.3463, -6.7987, -6.4333,
        -4.9435, -3.0053, -2.6191, -4.2430, -5.5315, -4.0528, -5.3230, -3.5901,
        -6.0262, -2.6692, -4.4114, -2.2623], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.7699, -4.1050, -4.8942, -4.7713, -8.8056, -5.3827, -3.3629, -3.4183,
        -5.6453, -3.3643, -7.5582, -4.6031, -3.2268, -3.0700, -7.3868, -3.8084,
        -5.0862, -7.8565, -4.6587, -4.1971], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -4.6943,  -6.9361, -10.7623,  -3.6289,  -3.1734,  -4.2444,  -3.2295,
        -12.3190,  -6.5984,  -8.3882,  -2.2804,  -5.1577,  -3.7676,  -3.5041,
         -4.9623,  -2.7727,  -3.7240,  -0.3915,  -2.7527,  -1.2063],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.0943,  -4.1292,  -8.5851,  -4.9229,  -3.3870,  -3.6934,  -4.7227,
         -3.9979, -11.7124,  -5.4637,  -3.3309,  -3.4210,  -6.5157,  -3.8722,
         -5.4765,  -2.4564,  -6.1932,  -4.5442,  -2.7430,  -3.9365],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-14.2877,  -3.9245,  -2.5211,  -3.3968,  -2.5323,  -4.1286, -14.1046,
         -2.9864,  -4.4077,  -2.7966,  -4.6056,  -3.7261, -16.4753,  -4.4175,
         -2.3024,  -3.6463,  -7.4976,  -5.9052,  -3.8829,  -7.7511],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -2.1794,  -6.1954,  -2.7162,  -7.0088,  -5.5478,  -3.0597,  -4.0688,
         -4.0857,  -2.9977, -12.9392,  -4.8772,  -3.5059,  -1.6962,  -3.6493,
         -6.4258,  -7.6084,  -4.7913,  -3.6644,  -4.0162,  -5.6348],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.7770,  -3.8137, -16.6730,  -4.3218,  -3.3822,  -2.7609,  -5.2413,
         -4.5242,  -3.8530,  -8.6614,  -6.0638,  -2.9698,  -2.5089,  -5.3122,
         -5.0456,  -5.4645,  -8.4006,  -4.5116,  -4.2369,  -3.4100],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-12.6408,  -4.9192,  -4.0125,  -2.4309,  -4.8691,  -4.5668,  -5.5046,
         -6.0701,  -4.3575,  -3.7059,  -2.0641,  -3.2663,  -4.7886,  -7.0521,
         -3.7130,  -4.5108,  -2.6767,  -5.6806,  -5.1861,  -4.7536],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.3564,  -3.5269,  -3.5161,  -5.0154,  -3.6395,  -8.0246,  -5.4284,
         -4.9947,  -3.7706,  -5.0051,  -5.4265, -13.7486,  -4.8299,  -3.1186,
         -2.7336,  -6.0428,  -4.4761,  -3.2046,  -6.9323,  -5.2962],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.0413, -10.6404,  -7.9162,  -3.1129,  -5.2887,  -4.7547,  -7.2774,
         -2.3798,  -3.7068,  -1.2094,  -4.8605,  -5.1917,  -4.4344,  -3.4509,
         -3.3206,  -3.8893,  -8.1314,  -8.0498,  -3.3180,  -3.1518],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-14.6372,  -4.5422,  -3.6073,  -2.5465,  -4.5473,  -5.7631,  -5.5002,
        -11.3317,  -2.4902,  -5.0369,  -3.9563,  -3.1574,  -4.6104,  -8.8637,
         -4.1240,  -3.5311,  -2.8543,  -6.2428,  -4.5025,  -4.8997],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.6197,  -3.9015,  -4.0663,  -4.6732,  -2.9501, -18.1232,  -5.8960,
         -3.6667,  -2.9549,  -3.7993,  -2.8167, -15.1191,  -5.9962,  -2.5776,
         -3.5735,  -6.3140,  -4.5174,  -4.1359, -12.4960,  -5.3373],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.4115,  -4.3962,  -6.5636, -17.8620,  -8.4355,  -2.2786,  -3.0415,
         -5.4127,  -6.7333, -11.3235,  -3.5131,  -3.7364,  -2.4082,  -5.3703,
         -6.0240,  -6.3709, -16.7671,  -4.9466,  -3.5084,  -3.2468],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-11.8709,  -6.2683,  -5.0729,  -2.9041,  -3.1278,  -3.0259,  -2.7251,
         -7.9877,  -6.2955,  -2.0796,  -3.7745,  -4.3790,  -3.4607,  -9.5813,
         -6.8407,  -4.4691,  -3.0856,  -3.2446,  -4.5536,  -4.7228],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.2938,  -4.4019,   0.3337,  -3.7534,  -4.3419,  -3.0778,  -5.2019,
         -1.9626,  -3.9230,  -3.4673, -11.1268,  -2.4039,  -3.2227,  -2.4403,
         -4.5766,  -6.2806, -10.2254,  -4.5912,  -4.0708,  -3.7811],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.0065,  -3.6572,  -5.9305,  -3.7021, -11.2728,  -5.8526,  -1.1319,
         -5.7885,  -4.1304,  -4.9501,  -4.7565,  -1.9363,  -3.7066,  -1.6653,
         -4.3454,  -6.9369,  -3.4551,  -3.4288,  -4.3791,  -5.1311],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.1980,  -3.1821,  -6.7817,  -7.8594,  -5.1162,  -1.9356,  -3.0616,
         -7.4768,  -1.9367, -11.1415,  -4.9539,  -3.1426,  -2.1632,  -3.7471,
         -5.1183,  -4.0063,  -4.5558,  -3.3198,  -3.7033,  -4.9582],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-3.0167, -4.8968, -1.7952, -2.5658, -2.9887, -2.9089, -2.2420, -2.9448,
        -3.8910, -3.0345, -2.6490, -2.4631, -3.0869, -2.3653, -3.3387, -3.0259,
        -3.4136, -3.1967, -1.9637, -2.8644], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -1.9211,  -4.8627,  -6.0911,  -3.8416,  -4.1630,  -3.9490,  -8.9502,
        -11.9184,  -3.7895,  -3.8511,  -1.4307, -13.2325,  -5.7277,  -3.3661,
         -2.3081,  -4.1734,  -6.1081,  -6.1993,  -5.7504,  -2.7208],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-4.8903, -5.6628, -2.6953, -2.3168, -8.0285, -4.9909, -3.7557, -5.6505,
        -4.5571, -3.3161, -5.3319, -5.3270, -9.2802, -6.6817, -7.6483, -5.0298,
        -2.2472, -5.4807, -4.3990, -5.0096], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.2189, -4.7756, -2.4871, -3.6582, -1.0879, -4.3469, -2.6180, -3.0837,
        -3.4674, -4.4144, -3.9698, -7.4583, -4.7588, -3.2435, -2.8786, -3.6318,
        -5.4841, -5.9243, -3.6634, -2.9882], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -2.6588,  -4.2566,  -4.9120,  -2.3579, -10.3252,  -6.1700,  -3.3893,
         -2.7906,  -6.3101,  -4.4909,  -5.2515,  -7.7623,  -3.5032,  -3.2792,
         -2.9625,  -5.4688,  -4.6398, -19.4317,  -4.8454,  -3.2910],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-10.6187,  -4.3943,  -2.9540,  -2.6903,  -3.7817,  -3.7215,  -9.3454,
         -7.4327,  -3.8450,  -4.5947,  -3.7884,  -4.5998,  -5.6622, -12.1303,
         -5.1596,  -2.9919,  -2.4770,  -3.8237,  -4.8070,  -6.3694],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.7353,  -3.3787,  -4.1366,  -7.8375,  -4.7489,  -8.0691,  -7.5979,
         -5.1300,  -2.9806,  -3.6750,  -3.5786,  -7.4448, -10.4394,  -4.7026,
         -4.0288,  -3.7138,  -3.5070,  -4.5786, -10.9647,  -5.1928],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-10.0961,  -4.2965,  -4.1984,  -5.8035,  -3.6786,  -4.5881,  -3.6425,
         -5.9875,  -5.1066,  -3.3352,  -4.2934,  -3.7503,  -3.5866,  -6.8639,
         -5.3196,  -3.9071,  -3.5987,  -3.8979,  -4.7398,  -5.7092],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.4365,  -6.4126,  -3.3442,  -4.3198,  -4.0488,  -7.1132,  -4.2156,
         -3.2206,  -4.3034,  -5.0563,  -4.8580,  -4.3061,  -4.9061,  -3.3011,
         -3.6315,  -5.3572,  -3.2311, -13.3151,  -4.5050,  -3.1227],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.3024,  -4.3884,  -5.0528,  -5.2812,  -5.4598,  -6.9986,  -5.7663,
         -3.5529,  -3.3734,  -5.4041,  -2.8797, -12.9657,  -5.3005,  -3.2110,
         -3.5298,  -5.1386,  -3.1174, -12.8680,  -6.0802,  -3.0312],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-4.5205, -3.8408, -3.3499, -4.4164, -6.4364, -3.9883, -2.8030, -5.4377,
        -4.9488, -4.9264, -4.5945, -7.4992, -3.9563, -4.0290, -6.4322, -3.2385,
        -3.6723, -2.4465, -4.4913, -3.9300], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -3.8801,  -8.5044,  -7.4421,  -4.1595,  -2.7771,  -3.3133,  -6.2332,
         -4.9502,  -3.8370,  -6.8950,  -5.6805,  -3.1053,  -3.7023,  -3.7217,
         -2.2426, -13.3128,  -5.5098,  -2.8618,  -3.7322,  -4.5298],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-4.4023, -4.6050, -4.0786, -9.0178, -5.1623, -3.1522, -3.1283, -5.2410,
        -5.4599, -4.4070, -9.4448, -5.2701, -3.1106, -2.4104, -5.3947, -4.8511,
        -5.0945, -7.2369, -4.4967, -3.6916], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -3.8463,  -4.5767,  -5.4825,  -3.9832, -15.3797,  -3.8483,  -3.0315,
         -4.3871,  -3.9526,  -6.9356,  -2.4609,  -3.6389,  -3.6105,  -8.3797,
         -3.6583,  -3.6053,  -4.1184,  -3.4446,  -6.3699,  -3.3856],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-5.1730, -9.4654, -4.0459, -5.1543, -3.4268, -4.5957, -5.9672, -6.5898,
        -5.2827, -3.4870, -2.1114, -3.7461, -6.6846, -4.3797, -2.6308, -5.7841,
        -0.9400, -8.0760, -3.8022, -3.2885], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -7.7852,  -9.4069,  -4.7056,  -3.2136,  -3.2195,  -5.8543,  -9.3545,
         -3.8629, -13.0644,  -5.5440,  -4.9603,  -3.9880,  -6.7901,  -2.7305,
        -16.6339,  -5.0815,  -2.2930,  -5.2268,  -5.2381,  -5.3977],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-4.5718, -4.0564, -3.0473, -3.2854, -4.9938, -7.4395, -4.6212, -4.0590,
        -4.8222, -4.0036, -4.5949, -6.1196, -4.7762, -6.7846, -4.1035, -3.2832,
        -6.0239, -6.5938, -7.8880, -4.1020], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -3.4534,  -3.4690,  -3.4096,  -4.9469, -11.6628,  -5.3591,  -3.9909,
         -2.2628,  -4.6070,  -4.1470, -12.1837,  -4.8652,  -2.1710,  -2.7039,
         -3.5686,  -5.3006,  -3.8358,  -9.2376,  -3.0996,  -3.0905],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.2647,  -2.2861,  -2.8361,  -4.5128,  -7.2819,  -3.8131, -11.7141,
         -5.1363,  -3.1193,  -3.4462,  -5.8783,  -4.9128,  -5.0344, -10.6227,
         -5.8770,  -3.4661,  -2.6364,  -3.1157,  -9.3591,  -7.8226],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-13.6246,  -4.4202,  -2.8909,  -4.0604,  -6.1379,  -4.5478,  -3.6640,
        -19.6116,  -5.1707,  -3.1075,  -1.7169,  -4.7753,  -5.9390,  -8.1414,
        -15.6521,  -3.8850,  -4.6817,  -2.3030,  -6.0406,  -5.1246],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-6.7374, -5.7007, -2.1104, -5.3026, -4.0841, -5.2501, -2.1568, -1.7635,
        -0.2347, -5.5656, -5.1736, -3.2176, -3.6445, -2.4522, -3.7756, -4.8682,
        -6.4202, -2.5641, -3.8433, -4.5226], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.2883, -3.4021, -4.1934, -5.0348, -4.3198, -6.8994, -6.0883, -3.4985,
        -3.0398, -3.6566, -2.4478, -5.0036, -5.2721, -3.5056, -3.9054, -3.7436,
        -4.9357, -7.1027, -9.2093, -4.2169], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -5.1458,  -7.8666,  -5.0636,  -5.7063,  -2.7288,  -4.2774,  -3.3486,
         -8.5222,  -5.1272,  -3.8932,  -2.8733,  -5.8774,  -3.2254, -13.8090,
         -5.8166,  -2.5949,  -3.1455,  -3.9299,  -4.6030,  -5.7696],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-15.1528,  -3.1017,  -4.6384,  -2.0553,  -3.7933,  -3.4744, -19.4879,
         -4.5091,  -3.2702,  -2.8507,  -5.6269,  -2.3029,  -9.3220,  -3.1145,
         -3.9019,  -2.6928,  -4.3812,  -3.6405,  -8.4617,  -5.2702],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-11.5546,  -4.8431,  -4.2409,  -4.9525,  -3.0081,  -5.9502,  -8.0519,
         -4.3977,  -3.8707,  -3.7856,  -5.4761,  -7.1448,  -5.3398,  -2.0648,
        -15.9452,  -3.5076,  -3.3912,  -4.0938,  -8.4026,  -6.1794],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.4723,  -4.0383,  -3.8459, -10.8372,  -5.1678,  -3.5890,  -5.0476,
         -1.5405,  -7.1125,  -6.8063,  -4.6109,  -2.7427,  -3.3716,  -7.4529,
         -4.5920,  -4.1067, -11.1625,  -5.3054,  -3.4928,  -3.1095],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.2257,  -6.6387,  -3.7229, -11.9576,  -3.2438,  -2.9632,  -2.6678,
         -5.1268,  -7.5389,  -5.3008,  -0.9476,  -3.9118,  -0.9969,  -9.6640,
         -6.6115,  -6.9890,  -2.5360,  -4.7378,  -4.8745, -14.4443],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -2.9081,  -3.6908,  -2.7674,  -4.2572,  -3.6060,  -7.4618,  -8.1805,
         -4.8577,  -2.5587,  -3.7277,  -5.9947,  -3.7896, -12.2667,  -4.8034,
         -3.5573,  -2.5518,  -4.9398,  -4.4647,  -8.6847, -14.4488],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-3.2562, -3.5812, -3.2763, -7.9986, -5.4135, -3.5475, -3.3699, -4.8190,
        -3.6540, -5.0638, -5.5608, -4.7415, -3.8177, -4.4832, -2.7889, -4.5496,
        -9.1698, -4.0527, -3.3908, -2.7337], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-6.5635, -4.1342, -3.4826, -3.2857, -3.9876, -9.3021, -4.1180, -4.7866,
        -4.3204, -4.7501, -2.5749, -5.3911, -4.8616, -4.7598, -5.8295, -4.6246,
        -4.0906, -4.3053, -4.4097, -5.7407], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -5.4105,  -3.0391,  -3.2629,  -3.4543,  -4.6134,  -3.9193, -11.3547,
         -3.2449,  -3.5648,  -3.6602,  -3.4337,  -4.8201,  -5.2378,  -4.5779,
         -4.0079,  -2.6131,  -4.5865,  -7.8250,  -7.6679,  -2.9766],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -2.9806,  -4.1485,  -4.7126,  -2.5981,  -4.4486,  -2.3242,  -9.1205,
         -4.6906,  -3.2753,  -3.1134,  -5.1169,  -3.9190,  -5.1853,  -5.9545,
         -5.4469,  -4.6727,  -3.1992,  -1.9028,  -4.5042, -12.1188],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.1962,  -5.6574,  -3.8398,  -5.7207, -10.4088,  -4.3161,  -4.9603,
         -3.4663,  -2.9638,  -4.7510,  -5.1883,  -7.9610,  -3.4734,  -3.0854,
         -5.7708,  -3.7806, -15.1501,  -4.5677,  -3.1801,  -1.9877],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.8078,  -3.0163,  -6.6181,  -4.5317,  -3.5279,  -3.4995,  -4.2048,
         -6.1364,  -6.1703,  -4.7868,  -5.7066,  -3.2752,  -7.3597,  -5.0717,
         -5.2605, -13.9261,  -4.9830,  -4.1684,  -3.7359,  -3.9334],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -6.1035,  -4.7471,  -4.0529,  -3.9006,  -5.3073,  -4.4153, -10.3687,
         -5.6075,  -3.0494,  -2.4876,  -5.0993,  -3.4423,  -3.4122,  -6.0669,
         -4.0880,  -2.8526,  -2.5668,  -5.1688,  -4.8969,  -3.7652],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-7.5652, -6.6561, -2.9914, -3.3665, -5.2563, -4.8537, -4.9728, -6.1843,
        -6.5229, -4.5723, -2.2302, -4.2776, -4.9296, -5.9496, -4.4323, -3.1918,
        -4.4038, -5.4145, -4.1527, -7.8874], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -5.0892,  -2.5881, -17.7217,  -6.8996,  -4.8106,  -2.6806,  -5.1518,
         -5.4306,  -3.5659, -10.3728,  -5.9483,  -3.0536,  -2.5088,  -3.6717,
         -5.2856, -12.8437,  -3.8502,  -3.4954,  -3.1350,  -4.1065],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-13.5729,  -4.6264,  -4.2665,  -2.1162,  -3.4996,  -3.8640,  -4.4049,
         -7.1002,  -5.0906,  -3.1471,  -3.3667,  -1.2680, -12.9668,  -4.1691,
         -4.6261,  -4.1456,  -3.5230,  -4.1696,  -7.8283,  -2.0144],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.2027, -17.1040,  -5.0284,  -2.9892,  -2.9330,  -2.6170,  -4.3341,
         -4.7794,  -3.6630,  -9.4067,  -4.0916,  -1.6975,  -3.3457,  -1.0880,
         -4.5545,  -4.9615, -14.7639,  -4.7018,  -4.2370,  -2.9765],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.2145,  -2.4957,  -5.0478,  -0.7898, -10.5765,  -5.2293,  -3.7733,
         -4.5116,  -2.3971,  -4.1220, -11.8826, -12.6300,  -3.6371,  -1.7013,
         -4.4327,  -4.3592, -12.2665,  -2.2434,  -4.1237,  -4.0835],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.3229, -14.0791,  -3.9296,  -3.5734,  -2.6841,  -4.5325,  -3.5095,
         -4.4343,  -7.2580,  -4.1242,  -6.7814,  -5.5279,  -2.2947,  -5.2513,
         -5.5478,  -6.2237,  -3.5766,  -3.4049,  -5.2502,  -4.8572],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -2.7303,  -3.2856,  -2.6373,  -4.0803,  -6.7548, -10.6584,  -2.4712,
         -2.9009,  -4.7493,  -4.0802,  -9.0523,  -8.9938,  -3.7559,  -4.2816,
         -3.5245,  -3.1722,  -4.0678,  -6.1949,  -5.3426,  -3.0700],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-5.2620, -4.6038, -6.2730, -2.6338, -8.5586, -4.9333, -9.0031, -3.9977,
        -4.1341, -6.7580, -4.6949, -4.5814, -3.7812, -2.2445, -8.9714, -4.1702,
        -3.6144, -2.7921, -5.1951, -5.2033], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.5490, -3.8966, -3.2503, -5.1755, -5.1051, -4.6215, -8.0298, -7.5928,
        -3.1896, -4.2290, -4.1103, -6.8832, -4.4219, -4.4961, -3.0830, -4.4750,
        -3.1770, -7.6329, -1.5499, -2.3462], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -2.2660,  -7.0887,  -4.7845,  -3.7713,  -2.8816,  -2.6047,  -4.7179,
         -7.4970,  -5.3991,  -4.8586,  -3.3865,  -3.7065,  -5.7591, -11.7354,
         -3.1657,  -3.7622,  -3.0942,  -4.9111,  -4.7446,  -4.7316],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-4.7364, -2.9555, -3.5066, -4.7435, -5.8829, -8.1742, -4.6421, -4.1230,
        -3.4213, -3.5830, -4.1537, -8.9070, -3.8817, -3.9766, -4.2012, -4.9586,
        -3.5992, -6.5215, -5.5359, -3.9819], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -4.8837,  -3.8293,  -4.6657,  -8.9136,  -3.8430,  -3.8888,  -3.4228,
         -4.7103,  -3.7549,  -4.9758,  -9.7074,  -3.2389,  -4.8897,  -4.5800,
         -2.9033, -15.2346,  -4.5614,  -3.2307,  -3.6738,  -4.5287],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.0382,  -3.9529,  -2.9676,  -3.2919,  -6.5223,  -9.5748,  -7.1509,
         -5.2332,  -2.8773,  -4.7480,  -4.5202, -13.9319,  -5.2480,  -2.0724,
         -3.3736,  -5.3263,  -7.0828,  -3.2945, -10.2667,  -4.7310],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -7.7090,  -4.3841,  -4.6444,  -3.0298,  -5.1632,  -3.0679,  -8.4943,
         -2.1724,  -4.5312,  -4.2043,  -3.6243,  -4.9225, -10.4269,  -6.0795,
         -4.2078,  -2.0459,  -0.6810,  -6.2461,  -4.7166,  -3.0516],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -9.2568,  -4.1960,  -3.5287,  -3.0674,  -3.7674,  -5.3444, -11.7799,
         -4.8510,  -3.7225,  -3.0730,  -4.2427,  -4.7419,  -4.7444,  -5.0380,
         -2.7987,  -3.3719,  -5.3169,  -4.7397,  -6.5464,  -8.7430],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -2.9278,  -4.5862,  -4.1593,  -9.1739,  -5.1736,  -4.3362,  -4.4981,
         -2.8374,  -5.6453,  -4.0887, -20.3677,  -4.1628,  -5.3373,  -3.6560,
         -4.7535, -12.4981,  -4.3989,  -3.4096,  -1.5054, -11.7128],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-2.1364, -2.5896, -1.9113, -3.1551, -2.7000, -2.9383, -1.9397, -2.0140,
        -2.4838, -3.7809, -3.1535, -3.8277, -3.3828, -3.8170, -3.0749, -2.8190,
        -3.7862, -1.9221, -2.9113, -3.7102], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -4.2074,  -4.1625,  -4.6770,  -7.8109,  -5.8520,  -2.6335,  -4.9203,
         -5.5194,  -6.5450,  -1.8255,  -3.2218,  -0.7242,  -5.7601,  -7.6086,
         -4.0102,  -2.5172,  -4.9983,  -9.5210,  -2.8191, -10.6250],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-10.5789,  -4.0819,  -3.9257,  -4.7881,  -6.2499,  -3.5683,  -4.3000,
         -3.5023,  -1.9262,  -3.2519,  -3.6124,  -3.4094,  -4.2765,  -4.2474,
         -3.9948,  -9.7443,  -5.4735,  -2.9006,  -3.4119,  -2.3176],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-3.5007, -6.9340, -3.8740, -8.8776, -4.0744, -3.7313, -3.1950, -4.5443,
        -3.8274, -7.4308, -4.0371, -2.9252, -4.3615, -2.9792, -6.5940, -4.3238,
        -3.5917, -5.0378, -3.5682, -7.8978], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-12.4177,  -7.0384,  -4.1128,  -4.7257,  -2.1000,  -5.0242,  -5.5453,
         -4.9610,  -5.2368,  -4.0435,  -4.1356,  -5.6067,  -3.6767,  -4.2719,
         -1.7159,  -8.0951,  -5.2322,  -2.7017,  -2.8663,  -2.5894],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -4.7984,  -4.2803,  -3.0362,  -5.2609,  -4.4484,  -5.2081,  -7.8868,
         -4.7318,  -3.7361,  -3.0618,  -5.0986,  -2.7795, -10.4660,  -5.1771,
         -3.3688,  -2.2598,  -2.9163,  -4.7727, -11.3190,  -3.1088],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-12.1520,  -8.6402,  -4.3583,  -2.7071,  -5.4432,  -4.5287,  -4.1657,
         -8.6361,  -5.6504,  -2.5598,  -2.8967,  -3.3088,  -4.4858,  -8.2618,
         -4.5957,  -4.4039,  -2.2364,  -5.4452,  -6.4671,  -3.5160],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-3.7267, -2.2135, -2.6248, -8.0591, -6.1292, -6.2751, -4.5967, -2.5993,
        -5.3639, -3.7843, -4.8710, -6.2112, -3.5788, -3.5112, -3.3229, -4.9689,
        -3.7508, -9.8948, -7.2810, -4.2153], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -5.1668,  -3.0553,  -3.3223,  -4.3065,  -4.1872,  -5.1092,  -3.8585,
         -2.3215,  -5.4779,  -7.3625,  -4.1152,  -4.6720,  -4.3348,  -6.5990,
         -4.6905, -11.9298,  -5.2369,  -3.5219,  -3.4420,  -4.2024],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.6476,  -1.4808,  -8.0642,  -3.8366,  -3.0267,  -3.5809,  -5.2442,
         -5.4709,  -5.5334,  -6.7893,  -4.3341,  -2.7364,  -2.9541,  -6.4296,
         -4.7811,  -5.4098, -11.8503,  -4.9255,  -2.9814,  -3.0312],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-8.1086, -4.3515, -4.2694, -1.9299, -2.0237, -5.4060, -4.2314, -4.2920,
        -3.3297, -5.3259, -3.3334, -9.3430, -5.1581, -2.6695, -3.1339, -6.7385,
        -4.6151, -7.9956, -6.8901, -5.4295], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.8142, -3.2866, -2.5959, -4.0832, -3.7027, -2.8033, -3.3521, -2.9978,
        -4.2349, -3.4655, -3.4517, -1.7744, -3.1667, -2.3864, -4.9720, -4.1953,
        -3.3801, -2.6740, -5.2041, -3.7529], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.0721, -1.9960, -1.0589, -3.8184, -5.8147, -2.5415, -3.3152, -2.6480,
        -3.7963, -3.9464, -4.2795, -5.5373, -3.3405, -3.5225, -1.8497, -2.2804,
        -2.9637, -3.1590, -5.0535, -2.0038], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.1304, -1.8339, -5.5082, -2.5514, -8.5029, -3.8583, -2.9776, -1.3990,
        -3.5240, -5.1812, -2.9742, -6.4753, -4.5927, -2.5628, -2.0283, -2.1278,
        -2.7306, -3.6140, -4.0807, -3.3219], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.3612, -1.7800, -8.4249, -4.3713, -2.1682, -3.0403, -5.9890, -6.9009,
        -2.4415, -4.3924, -3.0761, -2.1907, -3.5241, -4.2406, -2.6247, -2.6729,
        -3.8715, -3.2638, -7.1375, -5.3661], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.7821, -3.9372, -3.7923, -0.9388, -1.7483, -4.3966, -3.6205, -2.4030,
        -3.4609, -7.8751, -3.0008, -1.9244, -1.3970, -6.2588, -4.1890, -2.5095,
        -3.2019, -4.5966, -4.6001, -2.6716], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.6952, -3.3333, -2.9557, -3.8177, -2.5092, -3.3425, -4.3445, -1.7673,
        -2.2157, -3.5852, -3.6544, -6.3363, -6.3146, -3.6613, -2.2681, -3.3461,
        -3.5054, -4.3913, -5.0057, -3.0534], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.6454, -4.1526, -4.5984, -3.9377, -4.4493, -2.1665, -3.5100, -3.3082,
        -4.9229, -4.4030, -3.4939, -2.7715, -3.6949, -2.9051, -7.7570, -4.2230,
        -2.9784, -2.4698, -2.9281, -3.1123], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.0043, -4.1184, -4.5061, -5.4362, -4.5500, -2.9117, -2.5972, -2.6582,
        -3.5578, -6.3650, -4.7283, -3.6020, -2.3685, -4.6861, -3.6353, -5.6960,
        -4.2046, -4.1526, -1.5597, -4.3239], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -3.5975,  -4.7486,  -3.5799,  -4.2577,  -4.4796,  -2.9461,  -2.9827,
         -3.2320,  -3.3477, -13.7861,  -4.5622,  -3.0209,  -2.3416,  -4.5871,
         -4.7272,  -3.6595,  -5.1221,  -4.7086,  -2.7728,  -2.0767],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -5.8123,  -4.5453,  -3.1931,  -2.0978,  -3.6106,  -2.7122, -10.0495,
         -5.1116,  -1.7992,  -2.4725,  -3.3274,  -5.6996,  -3.1127,  -4.4168,
         -2.5658,  -2.6749,  -3.2335,  -3.4579,  -8.4672,  -4.0837],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-2.6066, -6.4633, -4.0464, -2.1458, -2.8063, -7.2403, -2.7823, -3.9793,
        -3.4492, -0.6805, -4.4741, -2.2659, -1.6330, -2.2315, -2.7133, -1.5873,
        -3.9037, -4.5916, -3.1723, -2.8677], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -5.7493,  -1.6475,  -2.9031,  -3.6617,  -2.6132,  -8.8521,  -3.2239,
         -2.1698,  -1.5400,  -4.0170,  -5.2840,  -4.2398,  -5.9153,  -3.6248,
         -3.2762,  -1.5586,  -4.6404,  -2.6271, -15.6163,  -5.1523],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-3.8385, -3.3074, -3.6139, -4.8308, -1.3794, -2.5340, -0.8043, -6.9893,
        -3.5917, -2.0109, -2.3339, -1.6484, -2.5033, -5.4954, -4.9186, -3.3457,
        -4.3126, -4.1557, -2.8985, -2.9330], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.2325, -8.5477, -4.7136, -1.5250, -2.5453, -4.7094, -2.9313, -4.1703,
        -5.3516, -2.5686, -1.5370, -2.7278, -4.5346, -1.1774, -4.0308, -4.1193,
        -2.6246, -2.1372, -3.2777, -4.5458], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.8511, -3.0987, -2.3216, -1.1928, -4.3185, -3.4664, -2.2358, -3.8930,
        -3.1403, -4.4422, -5.1252, -2.9433, -2.0702, -2.3242, -4.3662, -7.0224,
        -4.2539, -3.6108, -4.2291, -3.3744], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -3.9453,  -3.4917,  -3.8496,  -2.5849,  -3.6952,  -5.4647,  -2.5106,
         -1.7950,  -2.5826,  -4.5768, -12.6223,  -4.5742,  -3.0614,  -3.2763,
         -5.3134,  -2.1469,  -2.0219,   0.5842,  -5.1565,  -2.6586],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-9.9350, -3.0063, -2.4281, -1.8031, -3.2022, -3.2536, -5.3523, -4.5856,
        -2.6038, -2.9732, -1.0302, -4.4635, -6.7690, -7.1615, -2.6569, -2.2768,
        -3.2346, -3.3836, -3.8247, -4.6021], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.5637, -1.7518, -2.5179, -3.3119, -3.3838, -4.4625, -4.2140, -2.4129,
        -4.5616, -5.2983, -5.9555, -0.8317, -2.4930, -3.9513, -4.8210, -4.4893,
        -2.4650, -1.2000,  0.6436, -4.0858], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.9822, -1.7870, -4.0093, -4.4320, -5.0160, -3.3281, -2.2316, -3.9292,
        -3.2294, -5.0038, -4.2438, -5.2261, -4.3208, -1.6128, -4.0899, -4.1062,
        -6.0738, -4.8713, -2.8023, -1.9218], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.9405, -4.7849, -1.7281, -3.8494, -4.0771, -7.3424, -2.1955, -1.2860,
        -0.4583, -4.4118, -5.4180, -3.5563, -4.6203, -1.8153, -4.6234, -5.0897,
        -6.9350, -3.8486, -3.4085, -5.3844], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.2558, -4.0078, -2.5404, -1.8423, -4.7660, -5.1134, -8.9040, -4.4278,
        -4.3114, -3.2780, -3.7405, -2.6900, -4.5535, -3.2435, -6.5141, -2.5466,
        -2.3123, -2.5763, -4.2153, -3.9985], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.5264, -2.0905, -3.7041, -4.2988, -3.5511, -5.0672, -4.4260, -2.5215,
        -2.1328, -5.1894, -3.8925, -2.9246, -2.5081, -5.3707, -2.9881, -4.4077,
        -3.1202, -3.4678, -3.4132, -4.4579], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.2279, -1.6156, -4.7985, -3.0117, -8.9056, -5.2335, -2.3283, -2.6864,
        -5.1889, -3.1492, -4.6761, -3.6149, -4.9404, -1.5684, -2.1327, -2.1663,
        -2.2429, -3.4384, -4.7281, -3.5767], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.1648, -2.9884, -0.8505, -3.8866, -5.3097, -3.4948, -3.1002, -1.7661,
        -4.0252, -6.5997, -4.3587, -3.7642, -3.1570, -3.7841, -2.9818, -4.7324,
        -4.1482, -4.1218, -3.3619, -4.8272], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.2142, -1.3482, -4.1282, -4.6691, -3.7733, -4.5725, -4.6576, -3.3275,
        -3.1435, -3.4074, -3.5981, -3.3897, -5.4038, -4.3503, -4.0457, -1.9968,
        -1.0652, -6.4276, -3.9293, -3.3893], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.7291, -4.7481, -4.8592, -3.6296, -2.9172, -2.9141, -3.2641, -2.8927,
        -4.6253, -4.8427, -3.0798, -1.9808, -2.7027, -3.0709, -6.0854, -4.7720,
        -3.0604, -3.4828, -5.0074, -3.3670], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.2794, -2.4068, -1.8537, -1.8970, -3.3319, -5.5474, -4.5901, -3.6331,
        -1.7513, -3.9818, -3.6088, -2.1539, -6.6608, -4.8456, -3.9456, -2.6252,
        -5.0805, -2.9962, -7.3867, -4.5126], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-10.5965,  -4.0122,  -2.5222,  -2.0207,  -3.0325,  -5.1254,  -4.5247,
         -4.6073,  -5.4370,  -3.7213,  -1.5256,  -4.9256,  -2.5825,  -7.6682,
         -5.5194,  -2.4918,  -3.3438,  -3.9047,  -4.6865,  -3.7160],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-6.3572, -2.7035, -2.4653, -3.5446, -4.3850, -4.8216, -3.8649, -5.2532,
        -2.9571, -1.4832, -2.2676, -2.9061, -3.7339, -7.4158, -2.0956, -2.8996,
        -4.3595, -3.2125, -2.8460,  0.4081], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -5.9667,  -5.3240,  -2.9834,  -3.4936,  -3.4905,  -1.5198, -11.1565,
         -4.5543,  -2.7587,  -3.8093,  -3.0545,  -3.8037,  -5.0033,  -5.3999,
         -2.8117,  -4.4597,  -5.3294,  -1.8358,  -1.7834,  -0.0990],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -1.6731,  -0.2952, -12.9262,  -3.6553,  -2.3222,  -4.0291,  -3.7282,
         -5.8943,  -1.9666,  -6.9446,  -4.2882,  -3.0626,  -2.1614,  -3.8562,
         -4.6004,  -3.1208,  -8.1215,  -3.1746,  -2.0202,  -2.8946],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-3.5525, -2.5340, -3.1643, -0.0658, -3.1228, -4.4584, -3.7783, -4.2158,
        -2.0472, -6.2150, -2.7712, -2.5809, -2.4702, -1.8543, -4.2975, -4.3124,
        -2.5737, -7.5681, -1.3254, -5.8690], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -2.5064,  -3.8479,  -5.7404,  -3.9823,  -3.0753,  -2.2010,  -3.8260,
         -2.7724, -12.6768,  -4.8870,  -2.5927,  -2.0829,  -4.9649,  -4.3452,
         -2.4226,  -7.7718,  -4.0668,  -2.1033,  -3.3230,  -4.6905],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-3.8928, -6.5728, -3.6741, -2.1347, -3.7313, -3.9841, -3.4925, -2.6103,
        -3.7436, -3.5346, -2.1906, -3.0668, -3.9674, -5.8201, -3.0106, -3.1695,
        -3.5825, -3.5740, -5.1850, -2.7377], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.1514, -5.5186, -5.3890, -4.1758, -3.5454,  1.1918, -3.9367, -3.7396,
        -4.6857, -4.8016, -5.0608, -5.1947, -2.9056, -4.3104, -2.0064, -0.0505,
        -4.0505, -4.5191, -2.9496, -2.7530], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.6389, -1.5667, -3.9963, -4.2597, -4.7981, -2.5259, -3.2964, -2.1666,
        -4.7021, -3.8918, -3.8718, -2.7167, -1.4392, -2.8545, -4.0759, -7.6106,
        -3.8808, -3.3687, -2.2096, -4.1574], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-7.7251, -5.1097, -2.4194, -4.5483, -4.1125, -2.4388, -4.0325, -4.2360,
        -6.0212, -4.4649, -4.6615, -2.0872, -2.8108, -5.6290, -3.3908, -3.2367,
        -3.7976, -5.1426, -2.5684, -1.9848], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -3.7173,  -1.9276,  -1.5214,  -0.2348, -10.3677,  -4.9260,  -2.5139,
         -3.5019,  -3.6142,  -2.1997,  -2.2400,  -3.7034,  -2.4735,  -3.9985,
         -5.5168,  -5.0741,  -2.3175,  -2.6168,  -0.5979,  -9.1902],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-3.9998, -4.8772, -3.8396, -6.8761, -4.6373, -3.9953, -1.7212, -2.7420,
        -4.7322, -4.2717, -5.3243, -5.4980, -8.0982, -3.1772, -3.0587, -1.8659,
        -5.4836, -3.9777, -3.5738, -4.4180], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-9.3078, -4.6764, -3.2014, -2.1108, -4.3026, -3.6050, -4.3411, -4.7941,
        -3.7242, -3.7606, -3.5173, -3.8951, -1.3101, -3.3657,  0.4808, -2.7399,
        -4.3310, -3.2641, -3.9930, -3.6535], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.9244, -4.6707, -3.3089, -2.3865, -3.5074, -3.0213, -3.5889, -4.1866,
        -3.3628, -3.6361, -4.2800, -4.0175, -3.5558, -2.8614, -4.1917, -2.4777,
        -2.2329, -4.0918, -5.7754, -4.7885], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.4647, -3.8113, -3.0713, -2.5380, -3.5792, -3.1071, -4.9735, -4.7168,
        -3.0780, -2.3008, -2.8868, -2.5693, -3.5771, -4.3302, -3.0904, -3.3957,
        -4.5321, -7.0998, -1.0144, -2.3799], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.1627, -1.3414, -4.4183, -2.6955, -4.1823, -6.0930, -2.7601, -2.0917,
        -3.3348, -3.8699, -3.4796, -6.5621, -3.2134, -3.5547, -2.8283, -3.4659,
        -4.0560, -3.9481, -4.6866, -3.4157], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.1392, -5.3021, -4.0240, -4.0514, -2.2121, -2.5740, -6.2059, -5.9946,
        -3.1799, -2.4759, -3.7515, -4.4405, -4.2486, -4.9724, -4.7045, -3.1794,
        -1.9428, -3.0243, -4.2551, -4.8604], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.4016, -1.8150, -3.8233, -0.4627, -7.7057, -5.1920, -4.0027, -3.9265,
        -3.5292, -7.1781, -5.9521, -4.7954, -3.7510, -3.5645, -2.9359, -4.2359,
        -3.3411, -4.1282, -3.9607, -3.9444], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -2.9050,  -8.3933,  -4.1379,  -2.5676,  -2.3046,  -3.8592,  -8.3066,
         -4.1040,  -3.4227,  -1.8290,  -3.6752,  -4.3625, -10.0526,  -4.4216,
         -2.8312,  -3.5918,  -6.4130,  -1.7345,  -4.2200,  -0.2934],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-3.6518, -4.2963, -3.4843, -2.8006, -2.9790, -0.0766, -5.7182, -3.9097,
        -2.3894, -1.7655, -3.7658, -3.7337, -6.0301, -6.0221, -3.1448, -3.6776,
        -5.9651, -2.7984, -2.5790,  0.1497], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.6408, -2.2955, -1.3900, -3.1855, -4.8250, -4.8814, -3.4818, -2.4597,
        -2.1146, -4.4925, -1.2123, -7.1741, -3.6173, -2.1621, -3.8806, -3.7254,
        -4.4423, -3.5727, -3.6841, -8.0479], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.9915, -3.7750, -2.9975, -4.8139, -6.5263, -2.5901, -2.1586, -4.1056,
        -4.4110, -5.2528, -4.7500, -4.9682, -2.9894, -1.6593, -5.1686, -4.4787,
        -3.7838, -5.9110, -3.8632, -2.9679], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.6429, -2.9830, -5.5947, -4.8726, -2.7934, -3.1106, -2.9199, -2.4497,
        -5.9588, -5.2306, -2.9028, -3.2738, -3.7331, -3.4465, -3.3238, -4.6159,
        -5.0748, -2.4516, -3.7648, -1.9504], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.5330, -4.4563, -3.5042, -4.1443, -0.2658, -5.0324, -5.2754, -3.3415,
        -3.5438, -3.6592, -3.6770, -4.5637, -4.5616, -4.4139, -3.3952, -2.8430,
        -1.9681, -3.2163, -6.1343, -4.8767], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.1318, -3.5951, -3.3185, -2.8748, -3.4862, -7.5414, -3.8328, -2.3457,
        -3.3825, -2.6240, -2.8123, -6.4884, -3.7397, -3.1331, -2.6245, -4.5165,
        -3.1420, -8.4141, -4.2194, -2.9548], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.2342, -4.1519, -5.4994, -4.8186, -3.5226, -2.3428, -2.9982, -4.5058,
        -5.7971, -5.2656, -2.1504, -2.3290, -3.7151, -4.0594, -4.2327, -2.8643,
        -4.9265, -2.5318, -3.7118, -1.9029], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.4925, -2.6316, -6.9638, -5.2539, -2.6551, -2.9507, -4.1498, -3.6509,
        -4.4295, -4.7725, -5.0178, -1.9828, -3.1326, -3.6074, -2.6033, -6.5896,
        -5.9408, -2.9030, -2.0034, -3.0257], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.8499, -4.9045, -3.5241, -9.7952, -2.5850, -2.7130, -1.2490, -5.5511,
        -7.6416, -4.2272, -2.6137, -0.1360, -1.8711, -5.1998, -2.7539, -3.0224,
        -3.7870, -3.0713, -7.8118, -5.1217], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.1071, -2.9573, -2.4314, -3.0441, -5.5340, -5.6804, -3.3951, -2.5161,
        -4.6697, -5.1380, -4.4679, -3.8739, -4.1570, -2.8701, -2.1552, -3.0830,
        -3.0733, -5.2613, -9.2526, -2.6634], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -6.6125,  -4.5810,  -2.9423,  -3.5247,  -4.3182,  -2.4308, -10.5665,
         -4.7641,  -2.1599,  -2.2347,  -3.7974,  -3.4255,  -5.2948,  -3.9049,
         -5.1826,  -3.3268,  -3.0763,  -3.5841,  -4.4735,  -5.9626],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-4.4498, -4.5983, -3.0395, -2.6670, -2.2777, -4.3510, -6.5523, -4.2861,
        -3.7745, -2.0108, -2.2694, -3.1094, -7.1146, -4.9260, -2.6572, -1.8290,
        -3.5103, -1.6724, -5.8354, -5.2836], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.4120, -2.7971, -3.8709, -3.9183, -6.1376, -4.1591, -4.4334, -2.3103,
        -4.0827, -4.2508, -2.9137, -5.2158, -6.2358, -3.6164, -4.9952, -2.6816,
        -1.2872, -3.3206, -3.1142, -3.7281], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.0351, -5.0943, -4.8736, -5.6943, -4.9616, -4.4209, -2.4310, -2.6392,
        -5.1785, -5.0064, -4.7356, -5.4669, -4.6585, -2.7893, -1.3653, -2.7930,
        -4.3620, -7.2489, -4.4360, -3.0448], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.0774, -4.0573, -6.0725, -1.5102, -2.6465, -2.2422, -5.4545, -6.7523,
        -5.1468, -2.8043, -5.8036, -5.3365, -3.9190, -5.0213, -5.3365, -4.0462,
        -0.5052, -4.5732, -3.1678, -3.0817], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.5040, -4.6268, -4.0377, -2.9747, -3.4322, -3.0718, -7.0972, -5.3247,
        -1.9387, -2.9870, -3.7433, -4.4670, -3.2913, -3.8591, -4.6363, -1.9272,
        -2.3697, -2.9484, -3.8531, -3.9990], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.7371, -2.7219, -3.9565, -3.8345, -3.4097, -3.4890, -4.3773, -1.9183,
        -4.6898, -2.1963, -8.4093, -5.8773, -2.1433, -3.8639, -3.4115, -4.1973,
        -1.9090, -8.1386, -5.2461, -3.8973], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -6.1440,  -6.4593,  -1.8108,  -3.9090,  -5.4570,  -2.2289, -11.4919,
         -4.0268,  -2.5316,  -4.6925,  -4.7393,  -0.8464,  -3.7533,  -1.8221,
         -4.9997,  -4.4226,  -2.9332,  -1.4415,  -2.5180,  -3.6956],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-4.0996, -2.6182, -1.6232, -2.8435, -4.7775, -5.3982, -4.4534, -2.8926,
        -4.4711, -4.5983, -4.4965, -2.2991, -2.6815, -0.7062, -1.4366, -3.1593,
        -1.8882, -1.9448, -2.9345, -5.6737], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.4083, -2.5601, -3.4682, -3.1961, -3.3027, -3.2462, -7.2770, -4.1191,
        -3.2579, -2.7835, -2.5063, -3.2946, -5.0357, -4.3065, -3.1206, -2.7654,
        -4.3975, -2.5442, -2.3960, -0.6610], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.1438, -9.4169, -6.8824, -5.8011, -4.2805, -4.7303, -9.7684, -9.1871,
        -2.5387, -3.4709,  0.4331, -5.6180, -3.0564, -2.2648, -3.6977, -3.8336,
        -4.2829, -1.8933, -2.8233, -5.0901], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.2472, -3.6026, -3.7255, -3.0411, -3.8076, -4.0391, -2.0267, -4.7579,
        -3.4622, -6.5605, -4.5422, -2.3728, -0.9476, -3.9031, -6.6794, -2.7017,
        -9.8543, -4.7440, -2.6091, -3.1493], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.4578, -3.6530, -3.5380, -2.7664, -3.8504, -3.4090, -4.7450, -4.3848,
        -3.9653, -4.2200, -1.9980, -2.3053, -3.1156, -6.7145, -5.3383, -2.3041,
        -2.5802, -1.6099, -3.1129, -6.8932], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-6.0986, -3.0573, -4.2186, -4.5931, -3.4463, -5.4646, -3.6574, -2.0009,
        -3.8780, -5.3802, -2.4499, -5.9260, -5.0731, -3.6203, -2.0823, -3.1619,
        -2.9147, -6.6984, -4.8344, -2.5710], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.4083, -6.1099, -3.3410, -2.7260, -2.9254, -5.3568, -1.6561, -1.8503,
        -1.4101, -1.8516, -4.6635, -2.9717, -5.2302, -4.1264, -4.5904, -2.7369,
        -1.2721,  0.8983, -4.0267, -5.1936], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.3558, -5.2831, -3.1645, -2.7036, -4.1093, -3.4915, -3.1743, -7.5305,
        -4.4075, -4.4587, -2.1724, -3.8441, -4.4363, -4.7953, -4.7843, -2.1665,
        -2.8176, -4.4384, -4.2175, -2.9739], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.1045, -3.0429, -0.6636, -6.4759, -5.1993, -1.9296, -2.8148, -5.4063,
        -3.2522, -9.5900, -4.3241, -1.8939, -2.8540, -3.1186, -5.2988, -4.0403,
        -6.8598, -6.3893, -2.7417, -1.9979], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.0058, -0.4437, -4.4075, -6.5593, -3.4578, -4.5258, -3.8149, -5.6413,
        -3.8087, -8.2146, -4.8306, -3.5009, -2.7184, -3.3667, -3.7931, -3.4189,
        -8.8560, -4.1693, -3.0581, -2.6962], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.2918, -4.1857, -3.3160, -5.8222, -4.2221, -3.4581, -3.6671, -4.4369,
        -2.0094, -5.7843, -4.1554, -1.6751, -4.4232, -2.7205, -2.7106, -3.4390,
        -5.8894, -3.4841,  1.0470, -2.2398], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.9549, -6.0801, -4.7733, -5.3599, -4.4682, -8.0500, -5.1899, -1.8422,
        -4.2529, -3.5130, -8.5984, -5.3621, -4.5748, -3.3579, -3.2544, -4.4682,
        -6.1475, -4.1814, -3.6360, -4.6878], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.0514, -4.7367, -4.8011, -2.2587, -2.4877, -1.2936, -3.2396, -5.8839,
        -4.3181, -3.9415, -2.9752, -1.8399, -4.3804, -7.3519, -3.7884, -2.6713,
        -1.6782, -2.9325, -4.2738, -4.4370], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.5189, -3.7467, -3.7664, -4.8030, -2.6972, -4.9209, -3.0213, -4.0322,
        -4.3333, -5.4134, -4.5016, -2.1238, -3.0099, -1.1463, -3.2750, -5.9696,
        -5.3597, -3.1607, -3.1399, -3.7256], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.8265, -2.7469, -4.3685, -4.9113, -6.4358, -5.6246, -4.2927, -4.2309,
        -1.7503, -2.6409, -1.7919, -4.8187, -3.6817, -3.0423, -4.8489, -6.0926,
        -4.6036, -2.7098, -2.2421,  0.1741], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.9096, -4.2864, -2.3097, -8.9936, -4.0821, -3.0056, -2.4566, -4.3914,
        -2.9860, -5.8319, -4.9195, -2.9014, -1.9259, -4.6821, -1.7952, -7.6442,
        -5.1512, -1.8728, -1.3395, -1.5785], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.9688, -2.0114, -4.4822, -4.5661, -3.2358, -4.5308, -3.6532, -6.4327,
        -4.5357, -5.1843, -1.8275, -3.3144, -3.8311, -3.7122, -6.4803, -3.7516,
        -3.3843, -3.5240, -3.2889, -4.3415], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.4092, -4.7104, -5.1072, -4.2321, -2.6602, -3.6877, -0.2281, -4.4015,
        -4.3402, -2.7346, -3.6627, -3.9298, -5.1907, -4.1513, -3.9663, -3.8819,
        -3.0402, -1.7294, -3.9721, -3.9122], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.5347, -3.0610, -2.7149, -5.8767, -4.9153, -2.7114, -2.3694, -2.2647,
        -1.7830, -8.5025, -5.2375, -2.6034, -4.0438, -3.7213, -4.3154, -3.9811,
        -5.1891, -4.3677, -2.6477, -2.8125], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -5.3198,  -5.2088,  -4.0767,  -2.8028,  -4.0883,  -3.7155,  -5.7540,
         -4.4867,  -3.5720,  -2.7724,  -4.8496,  -4.6580, -11.3141,  -4.2306,
         -3.4719,  -2.0333,  -2.5533,  -4.3020,  -4.5961,  -4.6059],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-2.5993, -3.3242, -4.8455, -3.9738, -4.8304, -3.4008, -3.6667, -4.8822,
        -5.1612, -2.0783, -1.1833, -0.2425, -3.8813, -4.1736, -3.2576, -2.4590,
        -1.7561, -3.4054, -6.7705, -4.5080], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.6596, -3.0919, -2.7639, -5.3069, -4.3345, -3.3698, -4.3438, -5.1181,
        -7.0459, -1.5503, -2.0615,  0.5474, -2.4108, -4.3540, -1.6904, -2.3114,
        -4.4390, -2.7447, -6.5679, -4.3331], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -0.8373,  -8.2647,  -5.0364,  -2.8474,  -3.8043,  -3.7886,  -3.3809,
        -10.9755,  -3.2120,  -3.5168,  -5.0175,  -5.2797,  -2.0879,  -2.7398,
         -2.6718,  -4.1940,  -5.7246,  -2.3643,  -3.1011,  -2.5425],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-1.5679, -2.5366, -7.4980, -4.6119, -3.9076, -4.0162, -5.2196, -3.8494,
        -3.8463, -2.5747, -2.6711,  0.5440, -3.4475, -5.9447, -2.9973, -3.0175,
        -1.8182, -1.6407, -5.4699, -5.1488], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-6.1696, -5.0447, -3.2794, -2.6240, -3.6683, -4.0508, -1.8228, -7.8117,
        -2.3172, -4.5114, -4.9178, -5.8586, -1.0376, -2.4830,  0.2879, -5.1020,
        -6.4196, -3.3619, -1.9493, -0.9757], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.7837, -2.4274, -4.5490, -5.6456, -4.8517, -6.2005, -1.8660, -4.7353,
        -3.1850, -3.2375, -6.3173, -3.3385, -3.0427, -1.9886, -3.7182, -3.7521,
        -6.2272, -3.9898, -2.5730, -1.7243], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.7250, -2.4700, -4.7250, -5.1750, -1.6639, -6.2541, -4.5072, -1.6150,
        -0.7598, -2.4419, -4.9313, -3.8151, -4.1471, -2.8920, -4.9187, -5.5198,
        -4.5459, -3.1838, -2.2951, -0.6606], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.5257, -4.0806, -3.6707, -2.3109, -3.8004, -3.5782, -2.0064, -2.5784,
        -4.4914, -3.1128, -8.3180, -5.0599, -2.9189, -1.9255, -4.5481, -3.4619,
        -5.4518, -4.6704, -2.9989, -1.5939], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.7400, -3.2046, -4.4466, -4.2041, -3.6595, -6.7712, -4.8611, -2.9946,
        -2.0164, -3.3209, -6.0649, -7.1955, -4.6552, -2.5687, -3.4772, -3.1074,
        -3.5129, -4.0740, -6.9456, -2.9606], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.3712, -1.7630, -3.4670, -4.0978, -3.4077, -2.2708, -3.2670, -2.7739,
        -3.9224, -7.7209, -3.8830, -3.5500, -3.0947, -3.8970, -3.3734, -5.4794,
        -4.8359, -1.9340, -2.1027, -1.9941], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-7.4024, -3.9137, -3.3119, -2.6023, -2.6333, -3.9979, -4.9657, -4.2863,
        -5.6868, -4.1386, -5.9279, -3.7859, -4.0278, -2.1236, -3.1634,  0.5497,
        -2.1857, -2.5273, -2.7688, -3.0011], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.6351, -3.4503, -4.1506, -4.1914, -2.4451, -4.5188, -3.8762, -3.7840,
        -3.4635, -6.3259, -2.4404, -2.9686, -4.1669, -5.1547, -6.7778, -4.2212,
        -4.9402, -2.9586, -4.5355, -7.5082], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.0588, -2.1018, -4.3270, -4.3833, -3.9625, -4.6744, -4.6272, -3.8618,
        -1.2877, -4.4511, -3.5048, -5.8888, -3.4710, -2.8179, -3.3082, -4.0380,
        -3.8576, -4.7058, -6.5813, -4.5080], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-10.1041,  -4.5753,  -3.4203,  -2.6419,  -3.9269,  -3.0661,  -3.4981,
         -4.6186,  -2.5954,  -2.7553,  -3.2413,  -3.8747,  -2.9452,  -7.1501,
         -4.1245,  -2.8099,  -2.4558,  -0.5979,  -4.9547,  -4.1194],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-5.3446, -5.0701, -2.5874, -1.9823, -2.1218, -4.0588, -2.7213, -2.9344,
        -3.6637, -2.3796, -9.4909, -2.3738, -3.4910, -1.1380, -4.6713, -3.8327,
        -2.0961, -2.7687, -2.9187, -4.5056], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -3.2897,  -4.6526,  -3.6969,  -4.6802,  -4.0071,  -8.1484,  -4.3666,
         -3.4019,  -3.1815,  -3.5818,  -2.6511,  -4.7395,  -2.8707,  -1.9190,
         -2.2189,  -3.3633,  -3.5272, -10.3404,  -4.2038,  -4.4126],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-8.2116, -4.8727, -2.0172, -3.6406, -3.4502, -3.2269, -2.3896, -6.4285,
        -2.0235, -6.0007, -2.1471, -1.0418, -2.9884, -4.9868, -4.4680, -4.0100,
        -3.4480, -4.6449, -2.3869, -4.3082], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.6747, -4.4946, -6.0033, -5.9744, -1.7087, -2.6695, -2.6879, -3.7004,
        -4.1123, -3.6233, -2.4953, -3.5781, -1.9826, -3.8808, -2.8872, -2.9871,
        -4.0276, -3.6239, -3.1637, -3.3699], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.3723, -2.8405, -1.8327, -3.4654, -4.3993, -4.2257, -9.9538, -4.4792,
        -2.8478, -2.0636, -3.7912, -3.4899, -7.6586, -4.3839, -3.0317, -2.8373,
        -3.6266, -2.5844, -4.1487, -3.1559], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -5.5959,  -4.4603,  -2.0825, -13.7444,  -3.4199,  -3.1482,  -4.2456,
         -2.5518,  -5.6946,  -3.1540,  -7.5313,  -3.8903,  -3.7002,  -1.5574,
         -2.9824,  -4.4275,  -4.5935,  -4.0140,  -3.6301,  -2.7829],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-2.5702, -2.4057, -5.0039, -2.3198, -6.5461, -4.5889, -2.0870, -3.2944,
        -2.8774, -3.7318, -3.6341, -3.2266, -3.6518, -3.5938, -2.2449, -2.8726,
        -4.2825, -6.7398, -4.6496, -1.6967], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -1.4927,  -2.7976,  -5.7233,  -3.0943, -11.4520,  -3.7907,  -3.4270,
         -1.8055,  -3.0005,  -3.6939,  -6.6675,  -6.0414,  -5.2690,  -2.3639,
         -1.6682,  -4.1182,  -2.3180,  -7.7071,  -5.1444,  -2.0285],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-1.5767, -2.0487, -3.7927, -6.8476, -4.2512, -3.2531, -1.9764, -3.7884,
        -3.4687, -3.8194, -4.6100, -4.9815, -2.4336, -2.2662, -4.6784, -2.0665,
        -4.2846, -4.6734, -2.1743, -2.2074], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.6574, -5.4646, -4.4831, -4.3797, -3.0533, -2.1696,  0.3208, -8.1036,
        -3.2738, -2.7794, -2.3929, -4.3786, -4.3548, -3.0719, -4.0096, -5.4406,
        -3.1635, -2.9845, -3.7028, -3.5266], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.6774, -2.6844, -1.8388, -3.3450, -2.5304, -4.9489, -3.8476, -1.5010,
        -2.3045, -4.3549, -3.1359, -3.6034, -2.9303, -4.4564, -3.7024, -2.4860,
        -3.2290, -2.8160, -4.1076, -6.3267], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.1459, -4.3744, -7.1305, -4.9384, -2.8476, -3.7395, -5.2869, -4.1360,
        -5.9750, -4.4784, -3.5051, -2.7688, -3.6417, -5.3319, -3.9557, -6.2419,
        -3.7128, -3.4374, -2.1025, -2.6826], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.4307, -3.6812, -3.4611, -6.1786, -6.1790, -5.3294, -4.5369, -4.1474,
        -2.5302, -3.6545, -2.9657, -1.1217, -1.5530, -4.7331, -2.0362, -1.9235,
        -5.5265, -6.5212, -5.6782, -3.4002], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.0751, -3.5256, -2.3586, -3.7800, -0.9804, -1.4232, -3.4997, -3.0155,
        -2.7939, -4.2939, -3.5978, -2.6225, -7.3602, -3.5384, -2.3304, -2.2627,
        -3.5613, -4.9635, -3.7112, -9.3197], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.9346, -1.6770, -2.9560, -4.7237, -4.9988, -7.8815, -3.6680, -2.4919,
        -1.7837, -2.8930, -5.2403, -8.1341, -5.3105, -2.9635, -2.3652, -4.2941,
        -3.3154, -3.3166, -3.9745, -4.9489], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -3.6935,  -4.7042,  -3.0195,  -1.9353,  -2.5676,  -3.7372,  -5.9262,
        -11.6104,  -5.8116, -10.4516,  -6.0698,  -4.8932,  -5.2222,  -4.2361,
         -3.2906,  -3.9688,  -4.1881,  -1.9770,  -1.1513,  -3.6831],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-1.8836, -3.1884, -5.9481, -4.5732, -4.1979, -1.8874, -3.0798, -3.2943,
        -8.7274, -4.6027, -2.6884, -2.6955, -5.4780, -4.5149, -3.9765, -5.2521,
        -3.3324, -2.4305, -2.4370, -3.4944], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.7391, -4.2694, -2.5612, -2.4799, -2.6536, -3.2470, -7.4832, -5.2697,
        -4.1437, -3.1862, -5.0580, -4.3319, -3.2257, -4.6229, -4.3038, -2.4508,
        -1.5364, -4.0661, -5.1295, -4.6639], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -2.7198,  -5.0291,  -2.7464,  -4.3370,  -2.9967,  -5.2094,  -3.6525,
         -2.7350,  -3.1006,  -4.7881,  -4.0296,  -2.9080,  -6.4976,  -4.3327,
         -2.4605,  -2.5111,  -4.7564,  -2.8056, -10.2342,  -2.5405],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ 0.3667, -4.2232, -3.6947, -3.1721, -2.9617, -5.0685, -4.3463, -3.9219,
        -3.6604, -4.8001, -2.8313, -2.6800, -2.3584, -2.8577, -6.8520, -6.5454,
        -2.4520, -1.8420, -4.5419, -3.3014], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -2.8542,  -4.5881,  -4.5073,  -5.1646,  -2.6203,  -5.1911,  -4.3689,
         -4.6576,  -5.4269,  -5.7392, -14.0283,  -2.4001,  -3.0267,  -0.4084,
         -3.3820,  -3.8268,  -2.4019,  -3.1748,  -3.3923,  -4.4801],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -3.8637,  -2.7902,  -2.2354,  -4.6546,  -3.8997,  -3.0632, -10.1949,
         -4.7922,  -2.7834,  -3.4027,  -4.0057,  -3.3558,  -8.5123,  -4.5686,
         -2.7313,  -1.4460,  -5.3404,  -8.4127,  -3.4447,  -5.8327],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ -8.8489,  -3.8035,  -3.8674,  -3.4967,  -2.5053,  -3.4435,  -4.0222,
         -4.5538,  -2.4378,  -2.7373,  -5.0285,  -1.8477, -10.1177,  -5.2650,
         -2.3335,  -2.3205,  -4.7709,  -3.9121,  -2.7509,  -8.5665],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-7.9145, -4.1014, -2.8489, -2.3145, -4.7689, -4.2022, -3.9543, -2.8935,
        -2.0158, -1.8380, -3.4997, -6.1424, -4.3077, -2.8826, -3.9898, -1.3496,
        -5.5388, -3.6169, -2.2820, -4.2361], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.9172, -4.2228, -4.2441, -5.4262, -3.4823, -6.0081, -4.5724, -3.4540,
        -4.6083, -2.5842, -4.6650, -0.8258, -5.1823, -3.7453, -2.5885, -3.2644,
        -5.0960, -3.4939, -3.2457, -4.8990], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.7921, -4.7426, -3.0903, -2.2660, -2.9571, -1.4688, -5.5200, -3.8101,
        -2.8173, -2.5098, -3.6044, -3.9951, -3.2919, -7.5909, -4.1686, -3.4351,
        -3.2924, -4.0706, -4.0359, -2.5908], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 1.3920e-02, -5.5692e+00, -3.0849e+00, -3.5961e+00, -1.6259e+00,
        -4.2541e+00, -5.6513e+00, -4.9568e+00, -3.8679e+00, -7.3905e+00,
        -4.9439e+00, -2.7268e+00, -1.3361e+00, -3.8157e+00, -5.0550e+00,
        -2.7399e+00, -1.4798e+01, -4.3703e+00, -3.1634e+00, -2.2479e+00],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-3.6325, -4.9178, -3.0942, -3.0582, -3.6804, -6.0214, -1.8328, -1.0919,
        -1.8305, -6.5471, -4.9532, -2.9300, -3.3283, -1.3421, -4.0256, -3.5195,
        -5.7845, -2.6489, -3.8261, -6.3203], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.8344, -3.6734, -3.1862, -2.8551, -2.8945, -3.3109, -2.1338, -3.2317,
        -4.8504, -2.5107, -3.4739, -3.9030, -4.2158, -4.0804, -4.3540, -5.3730,
        -2.7226, -1.9190, -2.3122, -3.6449], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.2136, -3.5787, -8.9043, -4.0087, -4.2315, -3.5848, -2.4991, -4.3227,
        -8.5809, -4.3744, -2.8357, -1.9055, -3.8548, -4.3823, -2.6772, -4.7011,
        -4.5811, -2.8906, -2.6347, -2.9501], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.2032, -1.1735, -4.2349, -2.6869, -4.8957, -4.6089, -2.8219, -3.1965,
        -3.3158, -3.2656, -2.5330, -1.9877, -3.3701, -3.2933, -2.3028, -1.7551,
        -1.3600, -1.0866, -4.1146, -2.7537], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.8855, -1.2936, -6.6031, -4.7162, -2.9417, -4.0713, -4.8078, -4.1721,
        -4.6917, -1.0587, -1.6212,  1.4920, -1.7352, -7.0532, -1.8936, -1.2902,
        -2.1130, -1.8687, -2.1885, -3.4293], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.5798, -4.7628, -2.7831, -0.8911, -3.8345, -4.2243, -2.9083, -4.4292,
        -4.1881, -2.6221, -2.0921, -3.9926, -1.6391, -2.1804, -2.8682, -1.2235,
        -3.6605, -3.6323, -3.8531, -2.0088], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.2621, -7.6542, -5.3987, -4.4305, -3.4237, -3.2468, -4.4049,  0.4136,
        -1.7595, -3.8103, -2.3559, -1.1253, -2.0658, -2.2476, -4.1505, -3.9057,
        -2.3790, -1.8937, -3.7128, -4.2756], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.9204, -2.4485, -4.6129, -3.9433, -1.7364, -1.9024, -2.4967, -3.4664,
        -1.8618, -2.4759, -4.6145, -2.1874, -1.1878, -3.3036, -2.5761, -2.7180,
        -4.7144, -2.3363, -2.5921, -1.5148], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.4111, -3.9195, -3.2432, -1.1101, -2.8626, -5.8832, -2.0536, -3.8073,
        -4.2291, -2.3358, -3.1450, -1.9813, -3.7458, -2.2489, -1.7558, -3.6755,
        -1.8146, -2.0659, -3.3279, -3.5554], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.5191, -1.8453, -2.5486, -3.5636, -2.3121, -4.8093, -4.8250, -2.1967,
        -2.2213, -3.7134, -2.1544, -3.1417, -2.8685, -1.8456, -1.0147, -4.0351,
        -5.0557, -4.5636, -4.1558, -1.7774], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.6971, -5.0334, -3.5261, -5.1292, -2.7861, -3.5129, -4.7247, -2.9111,
        -1.2972,  0.0948, -1.7025, -3.9164, -1.5029, -1.5107, -2.3121, -3.3326,
        -5.0525, -3.8202, -3.5364, -3.6717], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.1247, -1.5937, -2.3142, -3.7438, -3.3827, -1.1722,  0.1560, -3.3777,
        -3.6125, -4.5005, -3.0563, -2.6721, -2.0823, -1.7436, -1.6165, -4.6751,
        -1.8743, -0.7696, -3.7616, -2.2715], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.4610, -3.4605, -2.9875, -1.9211, -2.0314, -2.2604, -8.2684, -4.3577,
        -2.0503, -2.2645, -2.6368, -2.7313, -7.0762, -4.9016, -1.4000, -1.5669,
        -3.5659, -3.1104, -3.3052, -4.7123], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.3370, -0.8986, -1.8866, -0.5487, -4.5539, -4.3448, -2.4660, -4.2966,
        -4.5525, -5.0169, -4.4891, -2.0703, -2.7104,  1.0108, -1.9278, -4.8355,
        -2.6147, -2.6390, -1.9479, -2.3867], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.0990, -4.2072, -1.7548, -2.2769, -0.6508, -2.4553, -3.5824, -5.7076,
        -2.2194, -3.9852, -4.5793, -6.0148, -3.7110, -3.4528, -2.9341, -2.3077,
         0.4626, -2.9364, -3.3034, -2.6975], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.4028, -2.1984, -3.1790, -1.2830, -2.5858, -4.2437, -1.8441, -4.1633,
        -4.8923, -4.4525, -1.9692, -1.9485,  0.3282, -4.1085, -4.0810, -2.2058,
        -2.8103, -4.0388, -4.2972, -1.6080], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.3217, -4.0784, -3.5052, -1.1115, -1.0943, -3.2547, -3.4334, -4.0344,
        -1.4682, -2.4311, -3.0127, -2.9018, -6.7004, -4.1850, -3.3776, -1.8410,
        -4.6930, -3.5433, -3.0635, -3.2605], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.0225, -0.5878, -3.6550, -2.2823, -1.6849, -3.8691, -2.7421, -4.0601,
        -2.5545, -2.7838, -3.2811, -4.2672, -3.5663, -3.4150, -0.6225, -4.4236,
        -4.1717, -3.3187, -0.7476, -3.6720], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.1393, -3.1149, -4.0830, -5.1613, -3.3531, -1.1982, -1.7147, -2.7576,
        -2.6104, -3.2800, -2.7576, -1.6567, -3.2280, -3.4494, -2.3730, -2.0122,
        -3.8093, -2.4272, -0.8613, -2.1910], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.4230, -2.8817, -2.9194, -4.5601, -5.4233, -3.3267, -2.9999, -4.8082,
        -2.9219, -0.3927,  0.1665, -3.2152, -4.7904, -1.5854, -2.4715, -4.2001,
        -3.5602, -1.8382, -3.0764, -4.0878], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.5542, -4.6354, -2.7220, -1.2655, -2.9990, -2.9646, -2.8873, -3.2335,
        -4.2503, -3.1034, -2.1155, -3.7161, -2.7964, -2.2513, -4.6913, -1.7016,
        -0.7282, -4.2171, -0.6325, -1.4840], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -3.9325,  -2.3171,  -0.7201,  -2.8769,  -3.6176,  -1.5054,  -1.1357,
         -5.4518,  -1.4153,  -3.1071,  -1.4427,  -1.4797, -10.4475,  -5.0618,
         -0.0500,  -4.4838,  -4.2404,  -3.3469,  -4.4235,  -1.1966],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-2.6484, -4.0256, -4.1064, -2.9232, -3.1381, -4.1242, -4.1057, -2.5272,
        -6.3493, -3.9746, -2.0120, -1.3405, -3.1582, -1.0303, -2.9807, -4.0170,
        -2.7021, -1.6791, -4.3998, -2.3354], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.2708, -2.1041, -2.6562, -3.6584, -3.1135, -4.1659, -2.9899, -3.7379,
        -2.4323, -2.2586, -3.3812, -2.0251, -3.9554, -4.4224, -2.4720, -2.2857,
        -3.8024, -3.6030, -2.1535, -2.9269], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.5787, -3.1427, -3.8163, -2.8389, -2.1584, -3.1925, -3.3972, -1.4220,
        -3.7681, -2.8690, -2.4241, -4.6293, -4.1923, -2.1303, -1.5161, -1.7745,
        -1.5182, -1.9140, -3.7955, -3.0233], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.7290, -5.4780, -2.0260, -2.7430, -3.5570, -2.3364, -2.7265, -2.9188,
        -4.0158, -2.3880, -1.8367, -4.0469, -2.3015, -1.1111, -2.8706, -1.5828,
        -2.1442, -3.7286, -2.2167, -0.7201], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.1119, -1.1588, -2.8931, -2.8176, -4.0130, -2.2106, -1.0768, -3.4222,
        -4.1885, -2.4683, -4.5473, -3.7720, -2.6301, -1.0752, -3.8707, -1.3220,
        -9.7051, -4.1525, -1.9054, -1.7134], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 0.1939,  0.8083,  0.1507, -4.2146, -1.7500, -0.5307, -3.6305, -1.4345,
        -2.8213, -4.1969, -1.7837, -4.2762, -4.7200, -4.7383, -4.9756, -0.9556,
         0.0518,  2.4153, -0.5121, -5.8417], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.4304, -4.7808, -2.2757, -1.5733, -3.4157, -1.9797, -4.6839, -4.6104,
        -1.9160, -1.0703, -5.0656, -1.8956, -3.9605, -4.5886, -2.1612, -1.0992,
        -1.7230, -1.5552, -3.3010, -4.3343], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.5958, -2.0181, -4.2292, -1.8655, -3.8654, -4.1597, -2.9944, -1.4974,
        -2.8314, -4.4584, -5.7170, -4.0930, -1.9788, -2.0603, -4.3350, -4.5446,
        -2.5487, -4.1364, -3.5365, -1.7996], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.7195, -1.7711, -5.6381, -1.4650, -1.1924, -4.0434, -2.6053, -5.5737,
        -3.8162, -2.1126, -2.3740, -2.6567, -4.3966, -1.4457, -3.2213, -4.8550,
        -1.5302, -1.2070, -0.9513, -2.8774], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.3891, -1.6502, -2.8140, -2.2283, -1.4157, -3.9824, -2.5140, -4.7841,
        -4.4461, -1.3132, -1.4227, -3.9750, -3.7865, -2.0742, -3.0508, -4.6616,
        -2.4374, -0.6324, -3.6185, -0.4939], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -3.0460,  -3.4716,  -3.5512,  -2.5061,  -1.5958,  -3.7571,  -3.0833,
         -1.2381,  -1.7347,  -2.7360,  -2.2713,  -4.2487,  -3.3311,  -7.0303,
        -10.1918,  -4.4389,  -3.4106,  -3.8586,  -5.3737,  -3.2637],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-3.0545, -1.8065, -1.9798, -4.0789, -2.9927, -3.3137, -2.5973, -2.6886,
        -5.3040, -4.8893, -3.3405, -0.7584, -2.4115, -2.5836, -2.9771, -4.7174,
        -1.9370, -2.1612, -2.4072, -2.2480], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.6883, -5.5514, -4.6521, -0.8999, -1.9947,  0.7349, -0.4736, -3.6937,
        -2.0773, -1.8571, -0.4448, -2.5395, -1.1913, -6.6110, -3.0877, -4.3071,
        -3.2295, -4.0465, -2.2234, -2.4278], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.5982, -3.6084, -2.8844, -2.7897, -5.4491, -8.5330, -3.8836, -3.2218,
        -2.7422, -0.1177, -4.4517, -4.1363, -1.9141, -1.0910, -2.4523, -5.9653,
        -4.5542, -4.9225, -3.2978, -5.5552], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.8429, -4.5898, -2.1819, -2.8372, -3.1264, -3.4742, -2.5530, -3.6619,
        -5.2837, -3.3716, -1.9901, -2.2807, -2.9497, -3.7861, -3.0455, -4.0427,
        -1.9413, -1.0210, -3.3489, -3.5738], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.2027, -1.1495, -2.7267, -2.5252, -3.1817, -3.6366, -2.1826, -1.7267,
        -4.1494, -2.9912, -2.6603, -3.9290, -4.4522, -1.7814, -2.2774, -3.4748,
        -1.0251, -1.6198, -4.5302, -0.9424], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.5830,  1.8441, -1.9588, -7.0344, -1.9317, -1.4004, -1.6066, -1.5715,
        -4.0451, -3.8597, -3.2456, -4.1230, -3.8953, -3.7347, -2.0428, -2.2263,
         1.8090, -2.0694, -3.5072, -2.2510], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.6983, -3.4402, -3.0794, -4.3490, -1.7775, -1.6268, -4.1395, -4.0442,
        -1.2876, -2.5723, -4.4809, -2.5779, -1.8382, -2.9628, -4.3319, -0.9971,
        -5.1913, -4.8209, -2.5693, -2.8787], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.1067, -2.9646, -1.8008, -3.2419, -3.7985, -2.9161, -1.5974, -3.9644,
        -3.4471, -1.8594, -2.9856, -4.3032, -1.9145, -2.3238, -4.4083, -1.8500,
        -2.7587, -2.7397, -6.7091, -3.0323], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.8368, -1.4612, -1.4563, -3.1756, -2.7082, -2.1427, -3.5500, -2.4839,
        -2.1722, -2.3667, -3.5750, -2.8666, -2.2044, -3.6824, -3.2404, -3.0574,
        -2.4972, -2.3105, -5.6968, -3.8215], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.7189, -4.3745, -3.9526, -4.0255, -3.6397, -7.9888, -3.2563, -1.7229,
        -1.0324, -2.6148, -3.6695, -3.6628, -5.1905, -4.0277, -5.8822, -1.4817,
        -1.5548, -0.7472, -3.9113, -6.3805], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.6745, -1.1769, -2.5213, -4.5527, -1.9977, -2.8047, -4.2332, -1.9795,
        -1.5957, -4.2902, -1.6079, -6.2654, -5.1861, -0.7171, -2.3958, -3.4926,
        -4.0601, -2.4121, -1.5936, -2.7465], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.9210, -2.3012, -1.7002, -3.3074, -4.7086, -2.9431, -5.0111, -2.1719,
        -1.2632, -4.2035, -4.6375, -2.2647, -1.8006, -4.1182, -2.2810, -1.6433,
        -3.1829, -3.7594, -2.7632, -3.0547], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.7856, -2.0456, -4.7669, -2.5767, -3.9935, -3.3720, -2.5655, -3.1542,
        -3.3501, -4.4649, -1.7180, -3.2836, -4.0608, -1.9803, -2.8279, -4.0172,
        -1.8919, -3.8433, -4.5304, -2.2227], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.2061, -2.1807, -2.9659, -4.3718, -2.3366, -1.1168, -3.0404, -3.8907,
        -3.2004, -1.2945, -3.8479, -2.4226, -1.2152, -2.0569, -2.8389, -1.9336,
        -5.7212, -3.7359, -1.8173, -3.7652], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.5304, -1.7705, -6.4004, -3.0850, -3.5156, -4.6677, -5.5843, -1.0206,
        -0.4402,  1.1447, -1.2046, -5.6575, -2.1511, -2.3614, -2.8043, -1.9819,
        -2.2707, -3.8157, -2.3813, -3.3073], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.1897, -3.7901, -1.1317, -1.1022,  1.1713, -2.5391, -6.7803, -2.8958,
        -1.4106, -2.2497, -0.8619, -4.1493, -3.8748, -1.3387, -2.9629, -1.9231,
        -5.3657, -3.6283, -8.4221, -4.7217], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.7505, -4.6943, -2.7466, -2.8193, -5.4491, -2.6520, -2.6671, -2.6163,
        -1.4013, -1.9561, -4.0887, -2.3339, -0.9746, -2.0813, -3.9443, -2.9774,
        -2.4150, -4.4344, -1.7165, -1.5803], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.6766, -2.4104, -1.5298, -4.0083, -4.0059, -0.9587, -1.1662, -4.2123,
        -2.7519, -1.0803, -2.7687, -3.4907, -2.8747, -2.6972, -4.7053, -2.5248,
        -1.1350, -1.4573, -3.3556, -7.2162], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.3916, -3.1835, -3.9748, -5.0695, -2.3833, -2.3535, -5.2137, -2.8505,
        -3.1772, -1.7716, -4.6703, -3.2158, -3.7460, -3.5724, -0.7140, -3.9113,
        -4.5096, -1.7452, -3.9630, -3.6001], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.0218, -4.4894, -3.6489, -3.3821, -1.5725, -2.1259, -3.8021, -4.0463,
        -2.9446, -2.0395, -4.3273, -2.6816, -1.3169, -3.0726, -4.5529, -3.1511,
        -3.6097, -3.9796, -2.2337, -2.3106], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.5048, -2.2854, -1.3770, -4.5016, -2.4371, -5.8978, -3.6531, -2.7899,
        -3.1001, -3.6851, -4.9596, -3.3380, -3.7334, -3.2280, -4.2718, -2.2788,
        -3.5406, -5.0844, -4.1986, -1.4052], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-6.9762, -2.3803, -2.3853, -2.4192, -0.8125, -2.2305, -4.6266, -3.0810,
        -2.8002, -3.0679, -4.0346, -2.3563, -3.8854, -4.1678, -3.8940, -2.4106,
        -2.8986, -1.5846, -4.6447, -3.8331], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.0463, -3.7468, -4.2737, -1.6479, -1.8724, -2.6969, -1.2896, -2.2795,
        -3.1430, -3.7462, -1.4377, -2.5139, -2.4603, -4.3449, -3.8586, -2.0825,
        -2.5454, -1.4023, -0.7343, -2.6945], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.2041, -1.8930, -3.9286, -3.7648, -0.1589, -4.8457, -2.7988, -1.3368,
        -3.2092, -3.4477, -2.9061, -4.8784, -4.1280, -2.4805, -2.4140, -3.3900,
        -4.2689, -4.9451, -2.4698, -3.1560], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.0972, -3.5792, -4.9262, -3.3430, -5.3726, -4.5143, -1.3771, -2.3683,
        -4.4546, -2.1760, -3.4701, -3.7531, -3.3624, -2.7188, -3.5742, -1.2927,
        -3.7066, -5.5657, -1.7543, -5.0072], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.5834, -2.2517, -3.0523, -3.2079, -3.0353, -3.3329, -6.6283, -3.1083,
        -1.6928, -1.2958, -3.9183, -3.6324, -3.7170, -3.1923, -3.0585, -2.7206,
        -3.4218, -4.6402, -6.5854, -3.6302], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.2829, -2.6508, -6.5320, -4.0523, -2.7473, -3.2153, -4.0031, -3.3180,
        -1.5711, -0.8332, -4.7190, -2.9388, -1.9786, -4.4578, -3.8720, -1.0534,
         1.5631, -3.2110, -2.8672, -1.3675], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.6527, -2.7860, -2.6890, -6.1112, -3.6328, -1.4172, -6.0381, -6.8202,
        -1.7804, -3.4202, -0.4757, -4.4883, -4.7017, -2.7886, -2.3989, -3.4083,
        -3.6039, -2.8207, -5.6759, -2.6934], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.2226, -3.2898, -2.3755, -3.4751, -3.9366, -2.3973, -2.1416, -3.9782,
        -1.9052, -2.0760, -2.0308, -1.9663, -3.5768, -4.2693, -2.2927, -5.1991,
        -4.6332, -4.7960, -1.4365, -1.7677], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.7598, -3.0442, -2.8065, -1.9390, -2.5057, -3.0525, -6.6084, -3.4499,
        -4.5053, -2.5911, -1.2333, -2.5518, -3.1855, -2.2153, -7.7630, -3.1365,
        -3.1726, -3.7325, -2.8424, -3.7238], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.5744, -3.0763, -2.2320, -4.2169, -2.5548, -3.7286, -4.6768, -2.0744,
        -2.5243, -3.1032, -2.6786, -3.5891, -6.2305, -3.9529, -2.1621, -1.6129,
        -3.0864, -2.2791, -4.7009, -4.4849], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.5478, -2.6191, -2.4822, -3.8856, -3.1954, -0.7824, -3.2664, -2.7103,
        -3.6998, -3.9142, -1.7038, -2.6316, -3.7644, -2.9615, -4.2020, -1.5231,
        -2.0852, -3.2087, -4.2698, -2.9714], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.6404, -4.7508, -4.3453, -3.6867, -1.6418, -2.9315, -2.6294, -4.2427,
        -4.6310, -1.9672, -0.7428, -3.8440, -1.8583, -1.9884, -3.6469, -2.9077,
        -1.9986, -3.8806, -3.4275, -3.3148], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.4030, -0.5786, -1.4442, -2.4543, -3.3271, -4.1087, -4.9901, -2.6892,
        -4.3776, -3.2328, -4.0250, -3.8361, -2.7533, -2.3348, -4.1398, -3.2662,
        -2.3076, -3.9903, -3.4759, -4.5265], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.8640,  1.5389, -2.8888, -3.1302, -3.2475, -3.2748, -3.3360, -1.7919,
        -2.5808, -3.3909, -2.9208, -3.0386, -2.9530, -2.7537, -1.5697, -2.8481,
        -4.5148, -3.7405, -4.6204, -4.4572], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.7241, -5.9448, -3.1956, -4.5345, -6.6427, -5.8511, -1.1611, -2.5886,
        -0.1578, -3.6761, -4.0080, -2.9251, -3.1664, -3.0207, -3.3839, -2.4516,
        -4.3034, -5.1094, -2.5624, -1.6779], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.7622, -4.6524, -2.5568, -1.6500, -4.3482, -1.8715, -3.7753, -4.9066,
        -1.7858, -1.3282, -4.1601, -1.2167, -1.5013, -3.8207, -2.5290, -0.9692,
        -3.1932, -1.7710, -3.2176, -4.4388], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.6282, -2.1517, -2.8703, -3.2789, -3.4879, -5.3152, -3.6982, -2.6627,
        -0.6423, -2.7054, -2.2957, -7.3815, -4.5081, -1.7067, -2.4179, -4.2764,
        -4.3943, -1.7499, -3.7137, -5.2081], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.0524, -3.5989, -3.4551, -4.3774, -2.4604, -4.0616, -4.0540, -2.2428,
        -2.8649, -0.9363, -1.3814, -2.0794, -3.3531, -2.2045, -1.6620, -3.1324,
        -3.4935, -1.7566, -3.1492, -5.2723], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.5360, -3.3352, -4.6072, -1.7876, -1.8277, -3.2721, -3.6206, -5.1900,
        -4.1023, -2.6777, -1.8727, -3.0778, -4.1477, -3.7954, -3.4943, -3.9827,
        -3.8811, -2.1196, -3.7421, -2.3915], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.3190, -1.9568, -5.2693, -5.6659, -1.8901, -1.6054, -1.7625, -0.8938,
        -1.9065, -3.3457, -1.7229, -2.8730, -2.9875, -5.9929, -0.4985, -1.3479,
        -0.6811, -4.2886, -5.1913, -2.1160], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.8871, -4.1817, -1.8113, -2.5312, -1.6494, -2.2214, -3.3664, -2.1544,
        -4.7985, -4.1269, -3.3515, -0.5651, -2.2011,  0.7506, -3.1647, -5.1569,
        -2.4597, -0.7610, -3.5230, -1.3909], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.5930, -3.8940, -2.3372, -3.2264, -7.6920, -6.5471, -1.5343, -2.9249,
        -4.1472, -4.3964, -4.8184, -2.6816, -3.5183, -4.0269, -3.6161, -2.9158,
        -2.9107, -4.3305, -3.1706, -1.9560], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.2041, -4.5032, -2.9241, -1.5046, -3.2339, -3.3459, -2.5157, -1.5012,
        -4.1933, -2.2322, -1.5390, -3.8910, -0.9266, -2.7373, -4.9549, -1.8007,
        -1.5135, -3.0752, -3.3638, -0.9966], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.2947, -3.0220, -4.3907, -3.7975, -3.9946, -4.6074, -1.6259, -2.7935,
        -1.9396, -3.8146, -3.4660, -2.9059, -3.4361, -2.9432, -1.5634, -3.1833,
        -4.7823, -2.2512, -2.6155, -2.4348], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.7168, -4.2214, -4.2334, -1.1670, -3.2287, -5.0528, -3.4273, -4.3711,
        -2.9097, -2.9122, -2.5310, -3.4060, -3.8969, -4.3655, -2.8765, -2.5091,
        -1.6951, -4.4537, -2.5970, -3.8081], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.0615, -1.0597, -3.1730, -5.6069, -2.6105, -2.1225, -3.2986, -3.0821,
        -3.0497, -4.1646, -2.7523, -3.1332, -3.6303, -4.8927, -2.3727, -1.9167,
        -5.1400, -2.1458, -3.1519, -3.3219], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-6.3191, -1.3815, -1.2475,  1.7544, -0.9666, -4.3788, -1.0462, -1.6123,
        -3.9022, -1.8265, -3.3532, -4.1610, -3.0381, -4.5835, -3.9226, -5.3622,
        -1.2844,  0.3153, -0.8018, -1.4670], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.8636, -3.6475, -3.8050, -4.7233, -2.8999, -1.9756, -4.9578, -2.0953,
        -1.8808, -3.0230, -3.3730, -2.6125, -3.9369, -4.2248, -0.5554, -3.6958,
        -4.9830, -3.1861, -3.5834, -3.3013], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.0412, -1.4632, -2.3770, -3.6307, -2.5099, -3.6567, -4.7004, -4.8599,
        -1.2709, -0.8886,  1.7380, -3.5227, -4.5325, -3.1455, -2.5003, -2.7932,
        -1.6024, -6.2971, -4.0153, -4.2335], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.2493, -1.9350, -1.4294,  1.2766, -1.9232, -6.0243, -1.7940, -1.4210,
        -2.0247, -2.0712, -3.4454, -4.6777, -2.2893, -5.2793, -4.0890, -4.6026,
        -1.2218,  0.2092,  1.0817, -1.1098], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.0548, -1.6702, -3.8115, -4.3287, -2.4244, -1.6648, -3.3230, -4.1838,
        -2.0114, -1.3060, -4.9810, -2.3257, -3.1490, -2.5024, -3.3188, -3.4856,
        -3.8792, -3.5645, -2.4966, -3.9077], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.2567, -3.1553, -3.2574, -2.3072, -5.0134, -4.7983, -3.1853, -1.8434,
        -4.1471, -2.6527, -1.0613, -4.2152, -1.5260, -0.3497, -3.0450, -1.8932,
        -2.5196, -3.9340, -2.7455, -0.8707], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.9155, -4.6700, -2.1977, -3.7964, -0.9901, -0.3007, -1.9729, -3.6583,
        -3.0219, -3.2922, -6.0830, -3.4665, -4.0822, -3.4201, -3.4690, -3.8280,
        -2.7689, -2.4738, -4.8465, -3.0198], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.2511, -2.7876, -1.7440, -3.2690, -3.0747, -5.2159, -2.2556, -3.9892,
        -2.3751, -3.0086, -4.1480, -1.2114, -3.5676, -3.6228, -3.0721, -1.5390,
        -2.5540, -3.1914, -3.9138, -3.3679], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.7903, -3.0363, -2.1538, -3.2510, -2.7938, -3.8143, -4.1255, -2.4665,
        -0.7496, -3.0175, -4.8120, -4.3158, -3.2972, -4.5271, -2.6400, -3.0087,
        -2.6351, -0.2132, -1.2868, -4.4175], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.3149, -3.1314, -0.1913, -1.9544, -4.7241, -2.3709, -3.7396, -3.4004,
        -2.1462, -4.6798, -3.2589, -2.5807, -2.8190, -2.2447, -2.9294, -2.7872,
        -4.1720, -3.8035, -2.6660, -3.2083], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.3971, -3.2281, -4.2212, -0.1216, -2.9319,  2.6981, -1.6930, -5.5958,
        -2.4702, -3.0065, -4.4978, -3.6168, -4.0677, -2.6545, -4.6572, -1.7920,
        -1.9112, -4.8833, -3.4888, -4.0637], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.7214, -2.2413, -2.8618, -2.6316, -5.5481, -2.4296, -2.6264, -6.6038,
        -3.1086, -3.4635, -0.1805, -3.1849, -4.5279, -2.1685, -0.2328, -2.9001,
        -3.5417, -5.4905, -4.1445, -4.1615], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.0976, -2.7627, -4.1878, -2.1173, -2.0102, -3.1151, -1.8868, -6.2934,
        -3.9799, -2.8254, -0.8515, -3.5688, -2.2553, -5.2525, -3.1260, -2.2410,
        -4.3964, -7.1180, -6.2386, -1.7266], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.5205, -4.5872, -2.1016, -3.8651, -4.8806, -2.1915, -1.6454, -2.7372,
        -3.2421, -2.4996, -5.0735, -2.2734, -0.7948, -2.5362, -2.3564, -2.8777,
        -3.9598, -3.0085, -3.3864, -3.5559], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.7198, -2.2497, -4.4236, -1.5686, -1.1446, -3.2545, -0.8518, -5.5595,
        -4.8034, -2.4846, -0.8360, -1.7883, -4.2376, -2.7390, -1.9895, -4.4422,
        -1.8969, -1.3539, -1.3572, -3.1290], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.6956, -1.6406, -3.1789, -2.8488, -3.8061, -4.0591, -0.5869, -2.6575,
        -1.7316, -4.0574, -3.4719, -5.2395, -4.8185, -2.9421, -1.0186, -1.5804,
        -2.0608, -6.0662, -4.5515, -3.4574], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.2357, -4.0957, -2.6116, -1.7542, -3.4259, -3.7479, -2.5593, -2.9897,
        -3.1745, -1.8962, -3.2139, -4.6870, -3.8938, -4.0227, -1.9580, -3.1118,
        -2.4762, -1.8744, -4.2658, -3.6108], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.3144, -1.8014, -3.6589,  1.3991, -5.3769, -4.7031, -2.2398, -1.6063,
        -2.9300, -4.7513, -1.3871, -4.3400, -3.6671, -2.1662, -0.8008, -3.8526,
        -3.5282, -4.0575, -3.4138, -3.1362], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.0082, -3.5187, -5.1037, -3.3803, -3.4931, -4.7991, -2.6914, -1.7855,
        -3.3790, -1.2939, -2.3810, -4.0130, -2.8892, -0.9819, -3.1340, -4.0713,
        -1.7895, -1.7229, -3.9617, -2.6717], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.0257, -3.0358, -4.3012, -2.6553, -0.9945, -3.3531, -3.2885, -3.9498,
        -4.4825, -2.0918, -2.4385, -1.6572, -0.5934, -2.2014, -3.4518, -3.4592,
        -2.7814, -4.2169, -1.3477, -1.5838], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.0371, -2.4862, -2.2367, -6.7360, -3.6792, -2.8341, -3.1373, -3.9716,
        -4.0263, -2.6786, -4.7169, -4.7001, -2.9724, -0.5538, -3.4025, -2.4196,
        -2.8901, -4.5946, -2.5953, -0.9120], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.1226, -4.0055, -8.2027, -2.1323, -3.2860, -2.6216, -0.6078, -3.1963,
        -1.8701, -3.2505, -5.0092, -2.4246, -1.8530, -3.9395, -3.9152, -4.9053,
        -1.2029, -5.0527, -1.8262, -1.7873], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.1423, -2.1888, -3.5496, -2.3176, -5.0327, -5.7240, -0.4125, -4.0014,
        -1.4031, -1.8540, -3.6006, -2.0731, -3.1120, -4.6141, -6.1682, -3.1328,
        -3.1747, -4.0546, -1.3990, -1.2226], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.8277, -2.9823, -3.5808, -4.0571, -2.8080, -4.6842, -4.6060, -2.8214,
        -2.7973, -2.3468, -3.0122, -3.2375, -4.5249, -1.9873, -0.9951, -3.0558,
        -3.5725, -1.0354, -5.9187, -2.1083], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.4305, -3.1430, -2.2555, -2.5900,  0.6919, -1.6614, -5.3584, -2.5360,
        -3.8000, -2.1378, -3.3568, -5.9537, -4.4932, -4.2962, -3.0077, -4.6073,
        -3.8808, -2.3644, -2.9431,  1.5799], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.3566, -2.8743, -2.9760, -1.9601, -2.4523, -2.5043, -8.4151, -5.7232,
        -4.9398, -4.5295, -3.6531, -4.0702, -3.9712, -3.6270, -1.6387, -2.0108,
        -0.4265, -4.4129, -5.6039, -4.0808], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.6930, -3.2448, -1.4700, -3.0270, -2.0873, -2.6146, -4.2345, -2.8473,
        -1.9924, -2.1590, -3.4234, -3.4603, -4.2600, -4.1703, -3.2053, -2.5625,
        -2.7857, -2.6222, -2.5834, -4.1406], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.3651, -2.3246, -5.3807, -3.3018, -1.7427, -0.7762, -3.7205, -3.0228,
        -3.8816, -4.2886, -2.5929, -2.2595, -2.5204, -2.7293, -2.3154, -3.9922,
        -2.9145, -2.2457, -2.6860, -3.4596], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.7845, -0.9791, -4.1533, -4.9148, -2.8904, -2.4105, -5.1647, -3.1784,
        -1.7041, -3.0653, -2.7371, -4.1035, -5.2485, -1.8315, -1.9163, -1.6565,
        -2.7990, -5.1693, -4.7025, -2.1307], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.1066, -4.4325, -2.1913, -3.8077, -3.9538, -1.4161, -3.8253, -3.7001,
        -2.6899, -2.4773, -4.4407, -4.4666, -1.5075, -1.4477, -0.2593, -4.9642,
        -3.9779, -1.4287, -2.7606, -4.0756], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.8295, -6.0321, -1.9776, -0.2646,  1.6613, -2.1146, -4.0599, -1.5987,
        -2.4212, -2.5954, -1.6088, -4.3552, -6.2817, -2.2905, -2.9973, -5.5769,
        -7.3284, -1.9369, -3.3415, -3.0022], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.6297, -3.3476, -2.6896, -2.6850, -4.9583, -2.8363, -3.5143, -2.2261,
        -3.0879, -3.3302, -3.2657, -4.1323, -3.7789, -1.3000, -2.4408, -3.1517,
        -1.4671, -3.1745, -4.5727, -2.6760], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.0784, -3.2405, -3.6753, -0.0418, -0.8162, -4.5452, -1.7891,  0.8038,
        -3.2343, -3.8762, -5.2798, -4.0921, -2.4310, -2.1245, -4.0852, -3.6231,
        -6.5232, -4.9846, -2.7001, -1.3231], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.7031, -4.7946, -1.3527, -2.3987, -1.8161, -7.4453, -3.1971, -5.8090,
        -3.0779, -6.3322, -4.3212, -4.3521, -2.9000, -3.0635,  0.1444, -2.3483,
        -3.3538, -1.9350, -3.3534, -1.4926], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 1.8812, -1.2706, -3.7136, -1.9854, -1.1959, -2.3184, -1.5119, -4.4120,
        -4.6605, -2.5255, -2.0702, -2.1444, -3.2867, -4.3632, -3.7711, -4.2686,
        -3.5604, -1.5119, -1.0179, -3.0820], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.9083, -1.6660, -2.5200, -3.0709, -3.6173, -4.1983, -2.8700, -2.4793,
        -1.8453, -3.6831, -2.5851, -4.4296, -4.2426, -1.3134, -0.3281, -2.2673,
        -2.9850, -5.1171, -3.0334, -3.7333], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.1930, -1.4274, -4.1895, -3.3980, -2.8630, -1.9426, -4.3036, -1.9850,
        -2.7185, -3.2295, -1.5580, -2.3860, -4.2545, -2.0237, -2.6059, -3.5872,
        -3.0857, -2.6277, -4.3209, -2.9424], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.8567, -1.8508, -3.5563, -1.3864, -1.0777, -3.3612, -1.4392, -2.7092,
        -4.1947, -2.2460, -0.4061, -2.8839, -4.0615, -1.8995, -3.9714, -4.9047,
        -2.0587, -1.1941, -1.4728, -3.0281], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 2.1811, -2.7458, -4.1734, -2.1974, -2.1357, -3.2927, -4.3116, -2.6753,
        -3.9736, -7.3597, -2.3289, -1.8948, -2.7668, -2.8348, -2.1042, -4.9105,
        -1.6749, -0.1422, -2.3013, -1.6135], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.4305, -3.1430, -2.2555, -2.5900,  0.6919, -1.6614, -5.3584, -2.5360,
        -3.8000, -2.1378, -3.3568, -5.9537, -4.4932, -4.2962, -3.0077, -4.6073,
        -3.8808, -2.3644, -2.9431,  1.5799], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.6778, -3.0588, -2.8298, -4.3924, -2.4550, -3.1119, -4.3869, -3.3376,
        -2.3505, -2.9873, -3.6473, -1.8587, -2.7466, -5.0640, -2.3641, -0.5951,
        -2.5606, -1.5916, -4.5021, -5.2038], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.7415, -1.7689, -4.5183, -2.5990, -4.0396, -1.6521, -2.0465, -1.7889,
        -2.7544, -4.4147, -2.4834, -1.9726, -4.0802, -3.9007, -1.5931, -1.4086,
        -3.1416, -1.7987, -1.3858, -3.7406], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.9318, -1.2581, -2.4670, -4.2005, -3.4929, -2.2345, -4.0962, -1.6975,
        -2.0635,  1.7630, -3.9844, -3.7561, -1.8335, -1.3522, -2.5493, -5.4832,
        -2.3953, -2.9705, -4.2234, -2.5599], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.8930, -1.0833, -2.8444, -3.5580, -7.3946, -4.8159, -2.8518, -2.1338,
        -3.1617, -3.7441, -1.2146, -2.7859, -4.3809, -3.0981, -1.8422, -2.0633,
        -3.1341, -4.2875, -4.2579, -2.6315], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.9791, -3.7501, -2.7139, -4.9762, -4.0201, -3.5413, -3.2710, -2.8987,
        -3.7037, -2.0859, -1.0524, -4.1370, -4.0813, -3.5026, -1.0064, -3.9187,
        -3.0100, -1.4492, -3.0818, -3.6287], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.6885, -2.2050, -3.9918, -3.6802, -3.0526, -1.0764, -2.8426, -0.4817,
        -1.2399, -3.9105, -3.0553, -5.1909, -4.3623, -4.5742, -5.1903, -3.3332,
        -1.4649,  0.3709, -1.1603, -3.0952], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.1092, -4.0805, -4.0286, -2.1139, -3.8630, -4.8539, -2.7501, -0.8894,
        -1.3024, -1.6255, -3.6074, -6.3756, -2.8409, -4.3138, -3.7958, -4.4708,
        -4.5766, -4.3144, -4.8314, -1.7265], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.8506, -4.0363, -3.5544, -2.7549, -2.0288, -2.8052, -1.9075, -4.6426,
        -1.9933, -2.2407, -4.4936, -1.0292, -5.5573, -5.1470, -1.9769, -1.9495,
        -3.1585, -3.4857, -2.1890, -4.4054], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.8965, -4.0295, -2.2847, -1.7548, -4.1553, -3.2767, -1.0432, -2.7687,
        -1.9591, -2.1115, -3.3187, -5.9171, -4.1688, -2.5001, -3.0360, -0.7764,
        -2.4080, -3.2863, -1.8712, -3.3229], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.8711, -3.4517, -2.6367, -3.6499, -2.1884, -1.6150, -5.5660, -4.1360,
        -2.6954, -2.7875, -4.3319, -1.5253, -3.3210, -0.3560, -2.4112, -4.5040,
        -1.9895, -2.8225, -2.0829, -3.0413], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.6124, -4.6328, -2.7918, -1.5921, -3.6460, -2.1780, -2.9118, -3.7323,
        -2.4889, -0.9831, -1.9533, -2.7626, -3.6099, -5.1380, -2.3260, -2.2801,
        -1.5890, -3.1620, -4.7761, -4.2724], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.4558, -2.8904, -1.0240, -3.5637, -1.4048, -0.8191, -2.3931, -4.2563,
        -1.7314, -1.3191, -4.4095, -3.4636, -0.9192, -4.4714, -2.5655, -0.5433,
        -0.4021, -0.2152, -3.0073, -2.5348], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.2798, -4.3654, -2.4511, -2.0317, -2.4510, -1.3144, -2.7946, -4.6131,
        -2.1378, -3.6874, -5.1898, -4.2844, -2.8038, -3.7757, -2.7539,  0.9798,
        -1.4540, -4.6237, -1.3769,  0.4222], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.5926, -4.1264, -0.9997, -1.9652, -4.1935, -1.8020, -3.4184, -4.2897,
        -1.3140, -0.4604, -0.3183, -2.7807, -4.4066, -1.7444, -0.9614, -4.0542,
        -2.6999, -1.1732, -3.9688, -1.5549], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.2050, -3.6389, -3.3272, -0.4093, -2.0687,  1.5535, -1.6557, -3.6961,
        -0.6545, -1.3280, -3.9771, -0.5433, -1.5338, -3.6396, -2.7312, -5.3702,
        -3.2783, -3.7975, -4.5941, -1.3596], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.3402, -3.9992, -4.6591, -2.5583,  0.0914, -2.7307, -3.0390, -0.7264,
        -2.2028, -1.0063, -1.6241, -5.1579, -1.5355, -1.5703, -3.0656, -2.6438,
        -0.8328, -4.0642, -3.0713, -1.8481], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.2895, -3.0410, -1.0316, -4.0177, -1.9241, -0.6671, -4.2997, -2.5405,
        -1.7469, -3.8556, -0.9600, -1.5036, -1.7931, -3.6724,  0.0430, -3.8464,
        -2.9616, -4.8009, -5.1340, -5.4529], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.6262, -4.1304, -4.0739, -2.5668, -1.3174, -4.5086, -2.3872, -1.1946,
        -2.8152, -1.4312, -1.6152, -3.9770, -2.0754, -0.7161, -2.2350, -3.4155,
        -2.5339, -5.3145, -3.6769, -0.9518], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.0385, -2.2712, -2.5578, -4.1250, -3.2835, -2.7192, -2.2067, -3.6084,
        -2.5269, -2.7652, -4.0828, -2.6921,  0.0716, -2.4490, -1.5961, -4.1368,
        -3.9060, -2.2428, -1.2075, -2.4923], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.0167, -1.0884, -3.5961, -2.7474, -2.3298, -3.2774, -4.9640, -2.5692,
        -2.0952, -4.2109, -1.9478, -2.7891, -5.0587, -2.2141, -0.8362, -4.2698,
        -0.7768, -1.3905, -4.2528, -1.9290], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.5251, -1.1025, -4.2511, -2.5322, -3.3886, -2.6025, -1.3632, -2.9987,
        -3.6990, -1.7886, -2.9703, -2.1127, -0.9641, -1.9383, -2.5165, -2.1734,
        -4.3130, -2.3841, -1.9376, -4.0195], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.2471, -4.7789, -6.7943, -1.1588, -0.8079,  0.6199, -1.6388, -4.0686,
        -1.4577, -1.3149, -1.7732, -1.5153, -2.5595, -4.3101, -0.6447, -0.4635,
        -1.9136,  0.1003, -1.2085, -4.3756], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.5684, -1.1202, -1.9035, -1.9718, -2.2357, -5.2096, -4.0298, -3.8472,
        -2.3794, -3.6072, -2.5706, -3.4054, -2.8064, -2.4992, -1.3764, -4.2063,
        -3.2995, -2.0308, -2.5749, -4.1360], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.8274, -2.0174, -2.7249, -2.1338, -1.4624, -4.2230,  0.1083, -1.9197,
        -2.5730, -3.0189, -4.7292, -4.0538, -2.5129, -1.5592, -3.8334, -3.8675,
        -1.8363, -2.4445, -3.3678, -1.6543], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.1646, -1.1009,  0.0939, -4.5747, -1.7605, -1.3006, -3.3833, -4.8083,
        -2.2127, -0.3034, -2.6098, -2.3879, -1.2467, -2.4510, -0.4166, -2.3803,
        -4.8259, -2.5363, -1.9078, -1.4889], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.1035, -1.0322, -3.3842, -4.0055, -0.1011, -3.0824, -3.6455, -2.5624,
        -2.4028, -4.4796, -3.8675, -1.1200, -0.7915,  0.5149, -2.6651, -4.0124,
        -1.0305, -2.0722, -4.1724, -1.0665], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.5207, -2.4793, -2.0400, -1.4950, -3.2137, -2.7077, -4.3161, -3.2380,
        -1.9816, -0.7281, -1.7142, -1.4340, -2.1635, -6.5478, -2.2523, -1.6760,
        -4.2178, -2.5832, -2.0145, -3.6035], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.4365, -2.8214,  0.1234, -3.2503, -6.7993, -2.2593, -1.1724, -2.9794,
        -2.7444, -2.6969, -1.5848, -3.4547, -2.7377, -1.1229, -3.5016, -2.6243,
        -1.6672, -4.5273, -1.1817, -1.5379], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.1162, -3.7963, -3.4965, -2.5804, -2.7285, -4.5645, -3.0234, -1.4970,
        -2.9353, -2.6531, -1.5245, -3.1138, -1.6239, -2.3856, -5.2001, -1.5648,
        -2.1967, -1.6306, -1.4368, -1.3329], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-6.9142, -1.8821, -5.0067, -1.7839, -1.6981, -3.0225, -2.5391, -1.7565,
        -0.7092, -3.1698, -1.3390, -1.2604, -3.7657, -2.1601, -1.2983, -0.7590,
        -4.5822, -1.6633, -1.9588, -3.3742], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.2227, -5.7005, -5.0711, -1.1360, -2.8493, -0.7820, -1.3635, -4.2029,
        -2.3190, -1.3074, -1.6786, -3.6968, -1.1173, -1.6722, -2.6413, -2.5177,
        -0.5934, -3.7725, -2.1787, -2.3942], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.3302, -0.9732, -2.2198, -3.2788, -1.8889, -1.2372, -3.1346, -3.9118,
        -0.7541, -0.7937, -4.0673, -3.4580, -0.1301, -3.3394, -1.1512, -1.4732,
        -4.2772, -2.3194, -2.1554, -3.3495], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.0890, -2.4557, -3.3023, -2.7400, -2.5796, -2.6372, -4.0487, -3.0380,
        -0.7610, -3.2209, -2.0677, -1.7874, -4.6754, -3.1746, -3.5811, -3.0608,
        -3.4213, -3.5986, -4.5708, -3.8514], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.7146, -5.3057, -4.1070, -5.5303, -4.3066, -2.1297, -3.8711, -0.8437,
        -1.9873, -3.7183, -0.5256, -3.8471, -4.1272, -4.2022, -7.3247, -3.8889,
        -4.5427, -4.9155, -6.1043, -8.0220], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.6601, -3.3753, -2.1686, -0.8038, -3.4578, -2.8589, -1.8766,  0.0875,
        -2.2264, -2.1093, -4.5497, -3.0327, -1.6023, -1.3700, -2.3799, -1.6159,
        -4.4465, -1.8363, -1.9924, -3.1199], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.6192, -1.7389, -1.5900, -3.8910, -2.9387, -0.9161, -1.0091,  0.8236,
        -2.2009, -5.0530, -2.5780, -4.2358, -4.8693, -4.0363, -1.5997,  0.9380,
        -0.2682, -3.7919, -3.7783, -0.7383], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.0290, -0.0704, -1.3761, -2.8492, -1.0649, -2.0039, -4.4314, -1.3663,
        -0.4647, -2.7352, -0.6363, -1.3473, -3.5827, -1.8596, -1.6693, -2.2547,
        -3.3999, -2.5734, -1.5562, -4.3414], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 0.8924, -4.4063, -3.9982, -3.4638, -5.7115, -4.6321, -5.2556, -2.5942,
        -2.0941, -2.1347,  3.1957, -0.8220, -3.1165, -1.1535, -0.4977, -3.2188,
        -2.4515, -3.8324, -3.6744, -2.3588], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.0601, -3.5038, -5.2863, -1.3059, -0.9963, -4.1906,  0.4618, -3.0920,
        -4.5622, -2.1706, -1.7403, -4.4032, -1.5854, -1.8780, -0.2886,  0.4857,
        -3.0918, -2.4227, -5.7782, -2.2232], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.6534, -0.5950, -2.7925, -5.2025, -2.8185, -2.1326, -2.4510, -1.1926,
        -0.4448, -3.9897, -1.2687, -2.1150, -2.8961, -3.1745, -2.2923, -2.3189,
        -2.3727, -0.6514, -0.6753, -2.0600], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.5961, -4.4804, -3.8844, -0.4652,  1.9746,  2.0394, -0.1569, -5.1799,
        -2.2742, -1.9453, -1.9116, -1.4184, -3.9239, -3.6023, -1.6181, -0.6558,
        -3.5559, -4.4285, -1.5811, -1.6758], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.1911, -1.4020, -1.1762, -3.5221, -1.5010, -0.8421, -1.3088, -0.5104,
        -1.7364, -2.9148, -1.7209, -3.4157, -3.5614, -3.4826, -2.0885, -3.1040,
        -3.9348, -1.9346, -2.0304, -2.2892], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.0052, -2.0438, -0.8339, -0.9223, -3.1017, -2.2822, -1.9647, -1.4232,
        -5.9424, -4.1002, -3.3361, -0.5865, -1.0669, -1.2922, -1.4323, -3.3360,
        -1.1723, -0.1655, -2.8497, -1.0411], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.7152, -2.9521, -5.2169, -0.6217, -0.8651,  2.4091, -3.2614, -5.2086,
        -2.5372, -1.9088, -0.9881, -4.9501, -2.4533, -0.3462, -3.8223, -1.2414,
        -1.3520, -1.6401, -2.2182, -3.6596], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.9233, -3.9682, -2.7945, -3.1442, -4.0547, -1.4211, -2.3703, -2.6015,
        -1.6334, -0.2294, -3.1599, -1.8062, -1.2849, -4.5042, -1.2520, -0.2432,
        -2.8662, -1.0031, -4.0645, -5.0964], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.5361, -3.2504, -2.1812, -2.9497, -1.7769, -4.5181, -1.6881, -2.2846,
        -3.3031, -0.9667, -2.0650, -4.5136, -2.7997, -5.8005, -4.9315, -1.6818,
        -2.5252, -3.7072, -1.9162, -0.7670], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.1948, -2.2188, -2.8871, -2.1418, -0.5923, -0.7743,  0.5601, -2.1670,
        -3.0305, -1.7239, -1.9578, -1.4715, -4.5865, -0.8882, -1.1755, -3.9137,
        -1.6626,  1.1533, -2.1917, -2.0797], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.6788, -1.4182,  0.6706, -1.5647, -5.3733, -2.1957, -0.8809, -1.2759,
        -1.9274, -1.5480, -3.8480, -2.2259, -3.8753, -1.9468, -4.1502, -1.1861,
        -0.5884, -4.2310, -1.2481, -0.8494], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.0978, -3.6570, -1.2804, -3.7369, -0.3821, -4.5985, -5.0734, -2.3424,
        -2.1345, -3.2750, -3.5588, -1.6288, -4.0981, -2.6005, -2.1856, -1.1166,
        -2.3963, -0.5659, -3.6699, -2.9177], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.4083, -3.7778, -1.0934, -2.6703,  2.3445, -0.5980, -4.4969, -1.5574,
        -1.3517, -5.3820, -0.9427,  1.8053,  2.5435, -0.9114, -4.0734, -3.1649,
        -2.3039, -0.6628, -4.1339, -1.9287], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.9478, -3.2624, -0.3632, -3.1569, -1.8891, -3.0962, -1.3146, -4.9734,
        -1.2312,  0.9544,  1.6002, -1.5926, -3.6940, -2.6115, -1.3300, -3.0888,
        -1.6265, -1.7431, -7.6592, -4.7684], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.7524, -1.2210, -0.9655, -2.0487, -0.4688, -0.5806, -4.7127, -2.3170,
        -0.3586, -2.1011, -2.5646, -2.5374, -4.0382, -0.4671, -2.1996, -2.6901,
        -0.4999, -3.7254, -4.4413, -2.7020], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.5030, -1.0492, -4.3309, -1.0677, -2.4559, -3.0891, -3.6529,  0.1354,
        -1.1641, -3.1547, -0.9091, -0.5238, -3.2603, -1.1955, -1.9485, -2.5869,
        -2.6328, -1.0682, -1.8139, -2.2550], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.9587, -0.6180, -1.9936, -2.0356, -4.4577, -1.6985, -1.1151, -2.0331,
        -2.7726, -3.5735, -5.3289, -3.4863,  0.3837, -1.7255, -1.5920, -2.4352,
        -3.7173, -1.9724, -1.7373, -3.8221], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.4901, -1.6411, -1.5818, -1.7708, -3.1740, -5.4509, -1.4132, -4.7843,
        -3.2738, -5.1274,  0.1084, -2.8870,  1.2842, -0.2794, -3.6397, -1.8979,
        -3.4966, -2.9607, -1.9586, -3.2764], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.4526, -2.0850, -3.5947, -2.5853, -1.9766, -3.4472, -3.0469, -2.1517,
        -2.2966, -3.5522, -2.1658, -1.4290, -2.3805, -2.5267, -2.3582, -3.7008,
        -4.3320, -2.9697, -1.6057, -1.9495], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.1545, -4.6461, -1.8298, -1.4502, -1.9879, -1.2063, -0.2263, -7.8131,
        -2.2252, -3.6929, -4.0461, -4.1520, -0.9155, -1.8913,  0.9940, -2.6003,
        -4.1634, -0.9734, -0.1976, -3.8108], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.4608, -0.8786, -4.5025, -1.1112, -1.2192, -3.1226, -3.9706, -1.5671,
        -1.3622, -4.4157, -2.4138, -1.6372, -1.7048, -2.0933,  0.3223, -3.4475,
        -2.1001, -0.0737, -3.7414, -2.2541], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.1818, -0.2597, -3.0788, -3.5883, -3.1878, -1.0272, -2.5459, -3.8806,
        -2.6223, -1.1240, -3.4692, -3.1104,  0.4054, -3.3790, -0.7082, -1.4053,
        -2.2769, -2.6412, -6.1426, -4.4486], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.1433, -2.1039, -1.0477, -0.2928, -0.9288, -1.4845, -4.0944, -2.2648,
        -2.7318, -1.9678, -1.5495, -2.5876, -3.9785, -1.7548, -2.1962, -3.0563,
        -2.6961, -2.0600, -0.1872, -3.8995], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.1223, -1.5790, -1.1937, -1.0016, -2.2288, -3.9121, -3.9280, -3.1322,
        -3.6318, -2.8445, -1.8475,  3.1320,  1.0294, -2.6228, -1.1480, -1.9510,
        -1.1920, -3.3183, -0.6023, -1.9695], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.3669, -4.4003, -1.2516, -0.5715,  0.5378,  0.1374, -3.1935, -4.6109,
        -2.5723, -4.4800, -4.1481, -3.5893, -1.3052, -1.5821,  0.6185, -1.3748,
        -4.3722, -1.1250, -2.5098, -0.7175], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.9251, -2.0985, -2.4456, -3.1937, -2.3457, -1.4944, -2.6051, -2.0912,
        -2.6942, -2.3220, -1.8680, -1.5686, -3.9072, -2.8216, -0.5625, -2.5779,
        -2.6853, -4.1615, -2.8790, -2.3966], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.6644, -3.9103, -4.3985, -0.5318, -2.7177, -3.1465, -3.0006,  0.0057,
        -2.8658, -4.0372, -3.0166, -0.2564, -4.2448, -2.5030, -1.9022, -3.0913,
        -2.8461, -1.8184, -1.3626, -4.7122], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.3725, -3.0269, -1.8468, -2.8391, -2.9082, -0.5403, -2.2160, -3.4599,
        -1.5277, -0.6183, -0.6896, -0.7764, -1.9478, -4.5854, -2.9888, -2.7914,
        -2.6749, -3.4191, -1.7064, -1.8822], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.4002, -2.2164, -2.9274, -1.1912, -1.9429, -3.8588, -0.8777, -2.2275,
        -3.0761,  0.3277, -1.3534, -4.6180, -1.7147, -1.3027, -2.0251, -3.0525,
         0.0148, -2.2672, -3.8323, -3.1664], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.7773, -2.5678, -6.8247, -6.1639, -3.3075, -5.1869, -4.1561, -3.9374,
        -0.9205, -1.3905,  0.6627, -0.7015, -5.8783, -2.6815, -0.2727, -1.4430,
        -2.1043, -1.9905, -5.7848, -2.4433], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.2438, -3.8180, -2.7610, -1.9683, -3.0059, -3.6541, -2.7614, -1.3793,
        -2.4585, -3.5767, -0.9813, -0.1704, -5.4228, -1.0085, -1.8418, -3.4640,
        -0.9756, -1.8420, -8.0358, -2.7103], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.4490e+00, -3.1718e+00,  1.9899e-01, -4.6716e+00, -2.6615e+00,
        -2.3136e+00, -2.9090e+00, -4.6119e+00, -2.0615e+00, -3.1612e+00,
        -3.9005e+00, -2.1450e+00, -1.6364e+00, -3.1139e+00, -4.8354e+00,
        -1.9831e+00,  4.7150e-03, -3.6889e+00, -1.3243e+00, -1.7156e+00],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-3.9672, -3.7273, -2.7400, -2.4845, -3.3970, -2.3116, -1.7811, -4.7880,
        -2.2125, -0.5435, -2.2709, -2.4971, -1.9060, -3.7026, -1.9665, -3.8300,
        -2.2354, -2.2200, -1.2357, -3.3692], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.2055, -4.8009, -2.1291, -1.7998, -3.0210, -1.5195, -1.2254, -4.6278,
        -2.3919, -1.5723, -2.2911, -2.7334, -2.9148, -4.4369, -2.2484, -1.2244,
        -2.7731, -3.6463, -3.0009, -0.5988], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.1098, -1.6013, -2.7789, -3.0322, -0.9078, -2.0881, -3.2604, -1.4226,
        -4.5874, -4.1292, -2.9278, -0.9599, -1.0020,  2.9066, -2.3262, -4.1346,
        -2.4744, -2.2866, -1.7937, -0.3475], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.3952, -0.1462, -1.3972, -3.4634, -2.0476, -1.6961, -4.4903, -1.9236,
        -0.4783, -2.6450, -1.7118, -1.9577, -3.9789, -2.3881, -1.7215, -1.9132,
        -3.3504, -1.8770, -0.8390, -4.0917], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.0026, -0.1416, -3.2308, -3.3553, -1.7351, -0.2911, -3.3552, -2.0507,
        -2.5034, -1.9766, -3.8710, -2.0025, -2.1051, -4.7997, -1.1398, -0.4839,
        -1.8796, -0.9281, -2.4892, -3.7184], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.8296, -1.2820,  1.6940,  0.0135, -2.9160, -0.9581, -0.9177, -1.9749,
        -0.3073, -1.3529, -4.5672, -2.4357, -2.6555, -4.5755, -0.9457, -2.1345,
        -0.0610, -0.8048, -3.2224, -0.7672], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.5619, -2.9472, -4.1695,  0.5126, -3.1794, -2.6336, -2.7029, -0.2939,
        -1.7929, -3.8938, -0.7091, -1.5443, -5.0583, -2.2008, -0.6034, -3.1150,
        -0.8274, -1.0114, -4.0892, -1.9353], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.1196, -1.7504, -2.7381, -2.9873, -2.5708, -2.7940, -4.4446, -2.0759,
        -2.0349, -4.0223, -2.5829, -0.3603, -2.2342, -1.2246, -0.1993, -4.5834,
        -1.7418, -2.8410, -2.1561, -1.6508], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.0653, -2.5764, -2.6439, -3.1583, -3.0005, -1.1496, -3.0635, -0.9653,
        -1.6819, -3.4224, -3.5522, -0.4150, -1.9773, -4.1632, -2.6723, -2.6819,
        -1.4156, -3.8134, -4.0632, -1.0741], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.0040e+00, -5.9926e-01,  2.6688e-01, -2.7194e+00, -4.2923e+00,
        -2.3205e+00, -4.9443e-01, -1.3047e+00, -1.7248e+00, -1.4477e+00,
        -4.2405e+00, -2.4460e+00, -4.7971e+00, -2.4255e+00, -3.1498e+00,
        -3.1210e+00, -2.6598e+00, -4.1673e+00, -3.2198e+00, -4.3507e-03],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-5.6359, -3.1783, -6.5933, -3.9861, -4.3626, -2.3062, -2.4738,  0.6163,
        -1.0419, -3.4233, -1.7052, -2.9580, -0.3849, -3.5802, -1.8895, -1.9524,
        -4.5073, -4.0095, -1.9135, -2.2193], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 0.1083, -3.7263, -3.2753, -2.2758, -3.6289, -2.6624, -2.4715, -3.5310,
        -2.3089, -1.7941, -2.3389, -2.6966, -2.1562, -3.7409, -4.9319, -2.0488,
        -0.0878, -1.7951, -2.2294, -1.9946], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.7462, -2.3236, -1.5360, -3.9255, -2.9265, -1.2262, -1.9609, -1.8815,
        -1.3181, -3.3401, -2.0493, -0.8739, -2.1498, -3.5409, -1.3546, -4.5888,
        -0.6887, -1.2397, -4.5613, -0.3488], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.9181e+00, -2.5340e+00, -4.6933e+00, -1.3952e+00, -2.5661e+00,
        -4.1520e+00,  3.9177e-03, -2.8495e+00, -5.3556e+00, -3.2387e+00,
        -2.0428e+00, -2.4499e+00, -3.5654e+00, -2.5363e+00, -3.0313e-01,
        -2.9250e+00, -2.2856e+00, -5.0466e-01, -2.7934e+00, -2.0911e+00],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-4.2912, -3.0219, -2.3189, -4.8074, -2.0310, -0.2010,  2.5244, -1.4581,
        -2.8177, -2.5818, -0.9596, -3.2795, -3.7049, -0.4475, -0.2425, -3.3043,
        -1.3698, -2.3559, -2.8907, -4.3821], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.5550, -2.3231, -2.2315, -3.3174, -3.5086, -2.3842, -0.6265, -3.0245,
        -1.1345, -1.3147, -2.7902, -1.2515,  1.5521, -3.7564, -1.9167, -1.7104,
        -1.3609, -3.0891, -1.7986, -0.6155], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.2676, -2.7582, -1.7925, -1.8286, -2.7326, -3.0999, -0.8435, -3.7300,
        -2.1018, -1.8803, -4.0446, -2.3670,  0.3907, -4.0872, -1.4752, -1.8900,
        -3.6304, -1.8764, -1.8448, -2.7267], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.7752, -4.0827, -4.7617, -3.3047,  0.0751, -1.1029,  0.3697, -2.0275,
        -4.8234, -1.9122, -3.0410, -4.0824, -0.6600, -0.8843, -4.4826, -2.6265,
        -3.7376, -4.0524, -1.9015, -2.8440], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.3504, -2.8383, -2.3145, -1.9285, -2.9241, -1.5840, -2.1815, -3.9497,
        -2.3519, -1.4740, -2.6798, -3.9800, -2.9783, -1.3045, -8.0200, -1.8011,
        -1.6612, -2.6557, -3.9954, -1.6313], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-6.3786, -2.6335, -1.0823, -2.5125, -2.2217, -2.5678, -3.5193, -1.6589,
        -1.2772, -2.2836, -3.9084, -2.5111,  0.1609, -4.0631, -2.7019, -1.0809,
        -2.1076, -1.0331, -1.9806, -3.8732], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.7990, -3.1408, -0.2788, -5.3633, -3.2505, -0.9561, -2.3807, -1.2803,
        -2.3845, -5.2319, -2.5072, -3.0413, -3.0272, -1.1221, -1.4051, -4.2679,
        -1.3482,  0.3342, -4.4841,  0.6735], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.4997, -2.1677, -6.7075, -2.0571, -1.7601, -3.6316, -3.0203, -1.9414,
         0.3114, -3.2750, -1.3054, -1.2446, -2.9248, -3.8131, -1.0973, -0.3966,
        -5.2073, -1.4984, -1.8259, -3.5395], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.5089, -4.0148, -3.6021, -1.6278, -2.3751, -2.8053, -2.1813, -3.7482,
        -2.7981, -1.2826, -3.6584, -4.7561, -3.1850, -3.9378, -5.0774, -2.1362,
        -0.6647, -2.9843, -1.1256, -1.6005], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.3873, -4.6961, -2.1764, -0.1787, -0.4972, -1.4810, -1.3402, -4.8834,
        -2.7316, -1.9365, -3.0889, -2.2479, -1.8428, -3.6300, -1.2350, -2.0807,
        -3.2784, -3.5879,  0.2325, -1.7553], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.0286, -1.0214,  1.0920, -4.4362, -1.9579, -0.6751, -2.0382, -2.5773,
        -2.5550, -4.1451, -2.8175, -5.0511, -5.3962, -0.6655,  0.4436, -1.4547,
        -0.0412, -4.4637, -2.2687, -2.9590], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.7012, -1.8130, -3.2965, -2.5552, -1.3883, -4.4313, -1.2313, -1.7088,
        -0.4510, -1.2430,  1.5462, -4.7106, -2.7738, -1.7542, -2.0225, -3.0748,
        -1.6508, -1.3661, -3.8863, -1.5180], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.1402, -2.4322,  1.4937, -2.0589, -3.4428, -1.6151, -2.7174, -1.6892,
        -0.6797, -2.0773, -5.2462, -2.5147, -1.4639, -4.5088, -0.0588, -1.9766,
        -0.9573, -4.7832, -4.3212, -0.9326], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.8609, -2.7085, -1.8018, -0.4756,  0.8559,  1.2138, -2.6492, -4.2736,
        -1.2066, -0.9173, -0.3785, -1.4606, -2.0599, -5.3794, -0.7856, -5.1158,
        -5.4008, -4.9238, -7.4023, -1.1753], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.1968, -2.4846, -4.9977, -2.4594, -3.5810, -0.0090, -0.4550,  1.6017,
        -2.1066, -5.0340, -2.4671, -3.8370, -1.9985, -3.9416, -2.3861, -1.3511,
        -2.6262, -2.9963, -1.2814, -1.2144], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.5603, -2.5213, -2.6701, -2.8551, -0.5739, -2.3266, -4.4189, -1.5440,
        -0.4940, -1.6034, -3.4191, -2.1289, -6.3537, -0.3278, -0.7537, -4.3387,
        -1.8863, -1.5016, -4.6586, -1.1386], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.3962, -1.1930, -2.7269, -3.4622, -0.5307, -2.3332, -3.7793, -1.5698,
        -1.4868, -3.2820, -0.2654, -1.7472, -2.9906, -2.3738, -1.5254, -1.0811,
        -4.5228, -1.5671, -2.8852, -3.7880], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.1422, -2.7123, -2.7243, -2.7527, -1.9197, -3.3140, -0.8908, -1.8522,
        -5.2209, -1.1369, -1.1265, -2.6470, -1.7838,  0.5086, -4.5250, -2.2443,
        -2.9281, -2.7484, -2.8569, -1.6541], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.9233, -0.7689, -2.0841, -3.3281, -1.6911, -1.2506, -1.1628, -3.5767,
        -2.0071, -1.4076, -4.9840, -0.1399, -1.1078, -3.5704, -2.0351, -2.3862,
        -4.9781, -0.9438, -0.2973, -2.2241], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.5265, -4.1532, -1.7363, -4.4792, -5.1348, -5.1350, -4.4629, -1.4788,
        -2.6264,  1.7383, -2.1168, -4.9427, -1.7801, -1.5887, -1.4846, -2.6543,
        -2.2670, -4.2898, -2.7826, -0.9556], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.4729, -0.3545, -3.7138, -3.0645, -2.0813, -0.1882, -3.3059, -1.6132,
        -2.1656, -2.2667, -4.6421, -4.3514, -0.3084, -5.3242, -2.1858, -2.7973,
        -1.3747, -0.1005, -1.6518, -5.3922], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.0538, -3.8114, -2.7449, -1.5389, -4.9271, -2.1683, -1.5936, -4.0164,
        -2.3994, -2.7626, -5.2777, -1.9189, -2.4274, -1.4472, -5.0755, -1.1325,
         0.0887, -3.5860, -2.2790,  1.0114], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.8408, -4.6479, -1.7331, -2.3553, -2.6046, -1.7189, -4.4313, -3.5121,
        -1.9916, -1.8651, -2.1658, -1.6768, -1.9219, -3.6617, -2.7947, -3.6694,
        -1.3808, -1.8906, -2.4366, -4.8470], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.4715,  0.2381, -1.9793, -3.5429, -3.0790, -2.2257, -1.3317, -3.8573,
        -2.1424, -0.9160, -3.6399, -2.4432, -1.7712, -4.1974, -1.0770, -2.2092,
        -4.1043, -2.0121, -2.3695, -3.2330], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -2.6688,  -2.0789,  -2.7606,  -4.9511,  -2.3146,  -2.3591,  -2.4717,
         -1.1696,  -1.8893,  -4.9086,  -2.2509,  -3.9919,  -3.8822,  -3.9428,
         -2.1596,  -3.9436, -11.4400,  -3.9678,  -2.2378,  -2.6753],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-0.6816, -4.1391, -0.8356, -3.1536, -0.6532, -1.2334, -2.8959, -5.4617,
        -2.3002, -0.7197, -1.3089, -2.5055,  0.3792, -3.2972, -2.8974, -5.2975,
        -3.8944, -3.2318, -0.1454, -1.2293], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.6583, -4.5520, -1.7703, -0.8997, -1.9370, -1.6056, -2.1350, -4.9087,
        -2.3044, -2.6980, -5.5147, -4.9291, -2.8542, -2.4750, -2.8714,  0.8250,
        -2.9319, -4.7481, -1.8618, -1.7683], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.2659, -3.8060, -3.6391, -2.0287,  0.3372, -2.3987, -1.4268, -2.7602,
        -3.2110, -1.1640, -0.1340, -2.4641, -0.6913, -1.0558, -3.0545, -2.0477,
        -1.2552, -5.0030, -1.4579, -1.1188], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.1964, -5.0707, -1.4879, -1.3653, -3.5655, -0.5110, -2.9085, -5.4120,
        -1.5148, -5.8240, -4.3344, -3.3415, -2.0218, -1.2362,  1.9848, -2.1720,
        -2.8389, -2.5354, -1.8608, -1.5626], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.9896, -1.4835, -3.0923, -2.4137, -2.0424, -4.4321, -1.9067, -1.2230,
        -3.0167, -2.5231, -3.0907, -4.7244, -1.3212, -0.9766, -0.6661, -3.0156,
        -1.2628, -4.0075, -1.1192, -4.4893], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.6012, -1.1950, -3.1453, -2.0158, -3.7177, -3.9804, -2.2130, -0.8730,
        -0.3960, -1.1165, -1.1800, -4.4929, -0.5941, -0.7680, -2.9963,  0.6011,
        -1.5859, -3.7958, -2.2942, -5.8393], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.3101, -1.1956, -1.5736, -1.2905, -1.2323, -3.6146, -1.9867, -0.0936,
        -2.4550, -3.3501, -1.5520, -2.5992, -3.9822, -1.0261, -2.1484, -1.0665,
        -0.2831, -1.7630, -2.6437, -2.1040], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.3638, -0.9469, -3.0312, -1.2017, -2.3022, -3.3300, -1.1333, -1.2495,
        -4.7809, -1.2560, -1.5216, -2.7662, -1.6150, -2.1062, -4.1919, -2.1691,
        -2.0671, -2.0421, -1.4389, -1.2541], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-11.4400,  -3.9678,  -2.2378,  -2.6753,  -1.5306,  -4.2070,  -2.8969,
         -2.4353,  -2.7301,  -2.9875,  -3.2645,  -3.5825,  -5.1414,  -3.6555,
         -4.7994,  -3.7882,  -3.1741,  -2.2990,  -2.2274,  -3.7756],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-2.1136, -2.1578, -0.7088, -0.3763, -0.5571, -3.9059, -4.5388, -1.8153,
        -3.9622, -4.5630, -5.7905, -0.2940,  0.8587,  2.0668, -3.1637, -5.7366,
        -1.6821, -1.8183, -3.3788, -4.5267], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.9607, -2.9349, -4.0977, -2.3358, -2.5890, -4.0975, -2.7092, -3.9580,
        -5.4101, -1.1300, -1.3212, -3.5759, -0.9626, -3.1112, -4.3267, -2.3736,
        -2.9497, -2.9611, -3.4443, -1.5995], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.2140, -1.7188, -3.5402, -3.2363, -2.1522, -0.7702, -3.8078, -2.2146,
        -1.0765, -1.5258, -3.4861, -1.5573, -1.7331, -4.8100, -1.4692, -1.5571,
        -3.9149, -0.0463, -0.2265, -4.5971], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.6356,  0.5891, -2.6231, -5.0086, -3.6481, -1.7423, -1.8129, -2.7541,
        -3.5456, -4.5532, -0.6183, -1.3420, -3.3791, -0.3791, -2.3873, -2.7103,
        -2.4831, -1.4115, -1.3940, -3.8297], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.5973, -4.9112, -1.7387, -1.8509, -3.7289, -1.1842, -0.8916, -3.3549,
        -3.7946, -3.2477, -2.8682, -1.1741, -3.3641, -2.2993, -2.4057, -0.6641,
        -2.9868, -3.0962, -0.6746, -1.1456], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.4594, -2.7908, -1.8113, -2.0848, -3.6393, -3.1933, -1.8399, -3.5467,
        -2.2547, -2.8013, -4.7425, -3.1095, -1.8888, -2.4731, -2.3099, -1.4965,
        -1.2018, -4.9672, -2.3600, -1.6228], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.9023, -2.4540, -3.9191, -1.4947, -1.4529, -4.5556, -1.5226,  0.1730,
        -1.5742, -0.5544, -0.5366, -6.1084, -2.5206, -2.4712, -2.5895, -2.9906,
        -1.4803, -1.6446, -3.6807, -3.3051], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.1880, -2.4522, -1.4179, -2.7201, -0.6968, -3.0443, -4.8862, -1.5203,
        -2.1698, -2.6217, -3.3276, -1.9928, -3.1271, -4.8289, -2.8183, -2.5536,
        -2.5332, -3.1047, -1.4638, -1.0540], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.1363, -1.9890, -2.2052, -4.3402, -2.3088, -0.8489, -4.2196, -1.0772,
        -0.3999, -1.7330, -2.9025, -2.0721, -3.6676, -1.4531, -2.3154, -2.4634,
        -3.7235, -2.8129, -5.4811, -4.7825], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.6905, -2.4128, -5.7034, -1.3689, -3.2550, -2.0184, -1.4586, -2.0346,
        -4.5084, -2.3313, -1.8678, -2.4059, -3.2250, -2.0373, -3.8262, -2.9903,
        -1.1208, -1.6931, -1.6607, -1.5053], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.4644, -3.1857, -3.5057, -0.8919, -1.1635,  1.3957, -2.9333, -4.2202,
        -1.4116, -1.4560, -3.9174, -1.0619, -0.2335, -5.5746, -1.3741, -2.3927,
        -3.6550, -1.3694, -2.8451, -4.7967], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.9576, -3.0842, -1.0054, -1.8036, -3.4238, -1.3559, -4.0605, -4.0644,
        -2.0479, -6.6680, -3.3987, -4.4021, -0.0614,  2.3282,  2.6036, -0.8622,
        -2.7276, -2.1238, -1.1964, -2.7567], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 1.4837, -2.5767, -6.8979, -0.4076, -0.3738, -3.0774, -3.7704, -1.2586,
        -1.8357, -4.7250, -1.3661, -2.1054, -2.4730, -2.4404, -2.2494, -3.2199,
        -2.0119, -0.1249, -3.2573, -1.7764], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.3805, -3.3361, -2.8188, -1.4798, -3.6134, -1.1344, -2.9481, -2.6449,
        -2.8279, -4.0817, -1.4918, -3.7288, -1.7152, -2.2991, -3.8972, -4.0060,
        -1.9061, -1.5764, -3.8660, -2.0822], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.0245, -7.7275, -2.7150, -1.7379, -3.4125, -5.8537, -3.7514, -3.6312,
        -0.8490, -2.0321,  0.3680, -0.8071, -4.7148, -2.2854, -2.0426, -1.6527,
        -4.5755, -1.4311, -0.9070, -3.1221], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.5114, -1.2392, -2.8737, -3.5492, -1.7610, -0.4699, -3.1135, -1.9650,
        -1.0513, -2.3588, -3.4379, -3.1000, -2.3145, -4.0072, -1.7475, -1.3418,
        -3.2022, -2.6532, -2.5316, -3.5500], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.1282, -2.2490, -1.3013, -3.1706, -2.6575, -0.5400, -3.9714, -2.3112,
        -0.0921, -3.7227, -4.3684, -2.7052, -0.8908, -2.8429, -3.6142, -2.7136,
        -2.8225, -3.1346, -1.0681, -1.0867], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.4875, -2.9323, -2.1680, -3.8486, -2.2346, -2.8606, -3.4765, -3.1841,
        -4.6368, -2.1153, -0.7261, -1.6964, -1.3798, -2.7814, -4.7556, -1.9309,
        -2.1201, -1.7022, -1.5646, -1.9712], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.2794, -2.0498, -3.3665,  0.1727, -2.4031, -5.1801, -1.7222, -2.7510,
        -3.5957, -4.4697, -1.8031, -3.3108, -3.5203, -1.4425, -1.9425, -4.2812,
        -3.2124, -2.7163, -4.0290, -1.0327], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.5082, -2.2387, -1.4741, -1.3216, -3.9159, -2.0262, -1.3216, -3.2518,
        -4.1404, -2.0556, -2.3575, -1.5216, -2.7646, -4.2997, -0.1772, -1.7298,
        -1.8392, -0.5941, -2.6999, -4.9264], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 0.8866, -4.5007, -1.8839, -2.0799, -4.6489, -4.0783, -1.4334, -1.0789,
        -3.3667, -1.6563, -1.5854, -1.6910, -2.6363, -0.7616, -4.1791, -2.3142,
        -1.9418, -2.8788, -0.5725, -2.1297], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.0294, -2.0200, -1.3416, -1.8194, -2.6840, -1.3202, -4.0940, -1.0174,
         0.1545, -3.6001, -4.7268, -2.1373,  0.6921, -2.9237, -2.5847, -0.6819,
        -2.7038, -4.3562, -2.5281, -2.6491], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.1459,  0.3052, -2.0705, -0.8158, -4.2569, -1.7312, -2.2022, -4.2357,
        -1.3570, -0.9601, -3.9691,  0.4826, -1.5370, -0.5116, -2.4311, -3.2065,
        -3.8449, -0.5117, -1.0684, -5.5329], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.0488, -1.7973, -1.3237, -1.9352,  0.7156,  1.9975, -3.5654, -2.2987,
        -0.8669, -4.3527, -1.2735, -2.8092,  1.7060,  0.1539, -3.7153, -1.3059,
        -0.2263, -2.8317, -1.5763, -0.5456], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.5460, -3.1557,  0.0160,  0.7453, -5.9244, -1.0691, -5.3276, -3.7200,
        -5.2992, -4.0173, -0.0130, -2.8115,  3.0711,  0.6539, -5.1513, -0.4537,
        -1.1778, -3.8368, -1.9296, -1.4194], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.5735, -0.2765, -1.9780, -3.5411, -2.1267, -0.6619, -4.0541, -0.9450,
        -1.3053, -2.8183, -0.0780, -0.2475, -2.5279, -3.9309, -5.2956, -4.3040,
        -2.1407,  0.9675,  0.2020,  2.7635], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.9055, -5.8810, -5.4852, -4.7200, -3.8983, -3.4353, -3.3252, -2.3119,
         0.0232, -2.4342, -4.7653, -4.3464, -5.2107, -5.4882, -3.2625, -4.5720,
        -1.1900, -4.3613,  1.0409, -1.9682], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.3533, -2.6730, -0.1257,  1.0636, -3.7013, -3.7260, -1.8332, -0.4451,
        -2.9383, -1.9053, -1.7484, -3.7386,  0.5407, -0.8874, -0.6610,  0.3103,
        -0.2551, -3.5446, -3.3371, -1.5608], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.5705, -4.6298, -3.6647, -1.9939, -0.2526,  1.4577,  1.4194, -3.7855,
        -5.0069, -1.5591, -0.5351, -3.2218, -2.1124, -0.4061, -5.2973, -2.8704,
        -2.0857, -2.6511, -1.1007, -1.8153], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 0.7324, -3.7344, -1.0259, -1.9868, -4.2950, -2.2864, -2.8292, -4.2846,
        -1.9749, -1.7720, -6.5192, -4.7355, -0.9269, -1.9116, -0.9539, -0.1839,
        -3.2232, -1.1557, -2.3127, -3.4429], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 0.5053, -1.6042, -3.6120, -2.2295, -2.7027, -3.3171, -3.0467,  0.6748,
        -0.9823, -3.2197, -0.9968, -1.8240, -1.9893, -1.5946, -1.2153, -3.4117,
        -2.1098,  1.0882, -3.3010, -1.6315], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.7601,  1.3137, -1.4296, -5.2977, -0.8424, -2.0795, -1.4411, -2.0097,
        -0.6186, -0.1603, -3.1439, -3.1146, -1.7460, -0.4337, -2.7042, -2.0913,
        -2.0709, -1.6929, -2.1993, -1.0102], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.4212, -2.2844, -1.6228, -0.9729, -4.0604, -2.8639, -2.4064, -0.4235,
        -1.3346, -0.8052, -3.9557, -1.7956, -0.1335, -1.1514, -0.9375,  0.4971,
        -4.4181, -1.4718, -3.5270, -1.8341], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.6805, -3.1925, -5.2164, -3.8335, -3.7055, -1.6622,  0.4224, -0.2502,
         1.2740, -5.2638, -3.9821, -4.0974, -2.3104, -2.1391, -3.5645, -4.3874,
        -2.6922, -5.5373, -2.8169, -0.2395], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.3735, -4.7098, -4.6398, -0.7194, -3.1721, -4.7232, -2.0064, -5.0206,
        -3.6392, -2.2431, -0.9998, -2.1979,  0.6994, -4.5556, -3.4638, -2.9807,
        -2.6983, -3.6022, -3.0110, -1.2751], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.8266, -3.3159, -3.2858, -1.5214, -2.9524, -4.4225, -1.9046, -1.8051,
        -0.9947, -2.0224, -3.6567, -2.5263, -4.4733, -4.5757, -4.7494, -1.3705,
         0.6833,  1.7952, -0.6758, -3.9148], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.3785, -2.3645, -0.6312, -2.2371, -5.1577, -2.4934, -3.5241, -5.8141,
        -4.8954, -3.2217, -0.4051,  1.0093,  1.4102, -1.1715, -4.9343, -1.9343,
        -5.5880, -4.2413, -4.0505, -4.1939], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.0638, -1.6391, -3.5954, -4.1975, -3.5614, -1.8501, -3.6241, -1.8800,
        -1.4784, -4.3129, -1.4001, -1.6173, -4.4556, -0.1188,  0.3027, -2.5099,
        -0.1572, -0.2587, -3.6733, -2.2044], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.0709, -1.9466, -2.4481, -1.7765, -1.5227, -1.6476, -2.5533, -1.4599,
        -2.4622, -1.7501, -2.0168, -1.4433, -2.1324, -2.0011, -1.3644, -2.9526,
        -0.7075, -2.5376, -1.9201, -1.6986], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.3781,  1.8244, -2.2783, -0.9164,  1.5196, -3.6132, -3.3573, -0.8023,
        -1.6180, -2.8465, -0.5588, -1.9570, -4.4968, -0.9868, -0.2898, -2.6125,
        -0.2399, -1.8733, -2.6536, -1.9993], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.6455, -0.8387, -0.5238, -3.7750, -1.1654,  0.1572, -0.4001, -3.9372,
         0.6550,  1.0983, -4.5494, -0.4365, -1.8703, -3.3098, -0.1024, -0.8924,
        -4.9731, -2.2405, -1.7574, -4.9852], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.1029,  1.3203, -4.9434, -3.1348, -2.9609, -2.7310, -3.7866,  1.7148,
        -1.8823, -3.4697, -2.8884, -1.6233, -1.2726, -2.9922, -0.2812, -2.1324,
        -4.5183, -0.8314, -0.7248, -4.1909], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.1134, -3.0393,  0.2220,  0.2878, -2.7567, -1.2326, -0.8032, -3.9705,
        -1.6982, -4.0095, -5.2392, -4.1246, -1.1534, -0.4232, -3.0373,  1.5853,
        -2.7502, -2.9023, -1.0635, -1.0793], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.7670, -1.3243, -3.0586, -1.1984, -0.9255, -3.0577, -1.7588, -1.1781,
        -4.2971, -1.5646, -2.5045, -1.7152, -2.4062, -1.7489, -0.6867, -3.8053,
        -3.5596, -1.6788, -2.2724, -2.0225], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.2795, -2.8193, -3.8248, -0.7572,  1.2429, -4.3142, -2.9252, -2.1914,
        -1.1421, -2.2238, -1.5826, -0.7336, -4.2494, -1.7455, -1.0081, -2.5585,
         1.1643, -2.0849, -4.8557, -3.0851], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.0019e-01, -2.8930e+00, -3.7704e+00, -2.0664e+00, -7.0370e-01,
        -3.3986e+00, -2.6595e+00, -1.2609e+00, -3.0765e+00, -3.8703e+00,
        -1.9692e+00,  9.8419e-04, -3.7810e+00, -2.8386e+00, -3.3464e-01,
        -2.7241e+00, -9.4506e-01, -5.2710e-01, -4.0658e+00, -2.8797e+00],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-2.1173,  1.7481, -1.0561, -3.5698, -1.2313, -1.0732, -1.4449,  0.2772,
        -1.6609, -5.0054, -1.4971, -6.0639, -5.1312, -4.1709, -2.5678, -0.6891,
        -1.6224,  1.2494,  0.1363, -2.8886], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.9855, -2.3026,  0.1396, -4.0853, -2.6992, -1.3575, -3.6257, -4.5015,
        -1.8665,  0.1013, -4.9426, -2.2795, -1.7628, -1.5116, -0.7288, -0.9451,
        -5.5500, -1.4320,  0.1595, -2.4615], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.2292, -0.6130, -2.3028, -2.7952, -0.6716, -1.4475, -2.7565, -0.2968,
        -2.3775, -1.1752, -1.1713, -2.9299, -0.9212, -1.1247, -2.1136, -0.5994,
        -2.1218,  0.0338, -0.6926, -2.2448], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.8813, -4.3341, -4.4255, -1.1867, -2.6246,  1.0583,  1.1423, -3.8603,
        -2.5977, -1.1960, -2.6304, -0.5741, -0.1014, -4.3822, -2.1392, -2.8303,
        -3.3330, -2.4069, -2.6893, -4.2378], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.9727, -2.2118, -3.0290,  0.6922, -0.9265, -4.4085, -3.0743, -3.0204,
        -4.0872, -2.8769, -3.3478, -4.7684, -3.1647, -1.1230, -2.6695, -1.6094,
        -2.7239, -4.4545, -2.5538, -3.2291], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.2706, -1.7516, -3.1797, -4.4112, -1.0064, -4.0105, -2.5602, -5.4957,
        -3.5982, -4.1940, -1.0054, -3.0440,  1.7341, -1.1394, -3.6199, -2.5763,
        -2.0111, -2.4672, -3.6177, -2.3461], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.1309, -1.2755, -0.5971, -3.4537, -4.4586, -2.5928, -2.6279, -4.4475,
        -3.1192, -0.8734, -3.9542, -4.9172, -2.5122, -4.2688, -2.5755, -0.1395,
        -3.9391, -0.6530,  0.0785, -6.5595], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.4721, -1.6130, -5.0061, -3.2999, -1.3442, -2.3868, -1.8691, -0.1797,
        -3.7014, -2.4751, -1.6296, -2.8111, -2.4504,  0.6950, -3.7114, -2.3064,
        -2.4373, -2.7423, -3.6375, -3.7956], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.5318, -1.7828, -2.0310, -1.1410, -1.2781, -4.4014, -1.5286, -3.4360,
        -2.7353, -3.5766, -0.7871, -0.6199, -5.4483, -2.2929, -0.6445, -2.0457,
        -3.6337, -0.1201, -1.1526, -5.5361], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.6957, -2.2829, -2.0531, -0.5403, -3.6138, -2.8305, -2.0460, -4.2955,
        -1.7970,  0.0839, -4.2196, -0.2764, -3.2649, -4.0105, -2.0740, -5.8163,
        -5.4256, -5.5914, -3.3192, -0.7661], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.2864, -2.6089, -2.7713, -4.6222, -2.4426, -0.0237, -2.0573, -1.9503,
        -3.3927, -2.4492, -1.8287, -0.5011, -2.2586, -1.6289, -1.4961, -4.8701,
        -1.2272, -2.8779, -1.7566, -0.7733], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.1219, -1.6932,  0.3633, -3.3869, -3.3478, -1.1852, -3.9162, -1.1814,
        -0.9686,  1.6555,  1.2761, -4.2822,  0.1072, -2.0674, -2.4993, -2.3960,
         1.5466, -1.7400, -5.4685, -1.6765], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.6741, -2.4844, -0.4867, -3.9347, -2.3246, -2.2723, -1.2465, -1.3290,
        -1.4960, -3.3683, -1.6131, -2.0700, -1.9550, -1.8634, -2.0613,  0.3895,
        -3.4357, -2.3108, -1.0635, -2.9711], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-6.1474, -5.6998, -4.3318, -0.2694,  0.1899,  2.6838, -1.7651, -3.2739,
        -1.7860,  0.2580, -1.2267, -0.3717,  0.3782, -4.0444, -2.5581, -6.6664,
        -3.7672, -4.7348, -0.6257,  0.5969], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.5214, -2.9524, -4.4225, -1.9046, -1.8051, -0.9947, -2.0224, -3.6567,
        -2.5263, -4.4733, -4.5757, -4.7494, -1.3705,  0.6833,  1.7952, -0.6758,
        -3.9148, -1.8720, -1.3117, -1.0843], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.4424, -3.9064, -2.8310, -0.9411, -2.3487, -5.1071, -1.2360, -0.5849,
        -0.9992, -1.3432,  0.0078, -5.4409, -1.5369, -1.0671, -3.9313, -2.4015,
        -1.5848,  1.0267, -2.8736, -1.7215], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.0744, -1.4424, -0.4839, -3.3381, -3.2724, -2.3280, -2.3130, -2.3876,
        -1.8039,  0.4263, -4.6052, -2.9182, -2.3748, -3.5739, -1.6191, -0.9783,
        -2.8182, -1.8175, -0.9692, -0.6103], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.0738, -2.7679, -0.8115, -1.1902,  1.9191,  0.9612, -3.3147, -0.3395,
         0.4547, -2.2557,  1.3974, -1.8918, -3.7314, -1.5189, -1.3359, -4.4275,
        -0.8861,  0.6429, -0.1774, -0.6130], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.4316, -1.4685, -4.2587, -2.2102, -2.4779, -3.5454, -0.5252, -1.7793,
        -5.4481, -2.2482, -2.8221, -0.7038, -0.7834, -1.2404, -6.2452, -2.1187,
        -2.1341, -1.1079, -3.9026, -1.8202], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.6684,  0.5664, -3.9085, -0.8585,  0.9740, -1.4179, -1.3775, -3.2509,
        -5.1814, -0.8241, -1.0584, -2.4375, -0.5235, -2.5016, -4.5930, -2.0794,
        -2.5489, -2.2005, -2.0595, -1.7322], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.4196, -3.6141, -2.7383, -2.8090, -3.2495, -2.8513, -0.7546, -3.1933,
        -0.1652, -0.5000, -3.6520, -1.8538, -6.0482, -3.0169, -3.8838, -1.1676,
        -2.4900,  3.0278,  1.3976, -4.7927], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.9824, -2.7995,  0.0509, -4.0114, -2.2228, -3.4516, -3.1183, -3.0591,
        -1.9923, -1.0738, -3.8037, -1.9471, -2.0749, -2.5567, -1.5175, -0.2846,
        -3.9912, -2.1814, -4.1054, -3.4500], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.7235, -2.2440, -3.2821, -3.6889, -5.0221, -3.6906, -2.2030, -4.3043,
        -5.2533, -2.5864, -1.8491, -2.9433, -2.7012, -4.7610, -0.8746, -3.2748,
        -4.1271, -2.2702, -2.6163, -4.4765], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.1456, -2.9064, -1.9368, -0.5096, -3.6032, -2.5141, -3.2382, -1.7752,
        -3.0854, -2.7788,  0.9093, -2.3294, -2.3179, -2.3189, -1.0276, -3.9795,
        -1.8986, -0.9425, -3.9083, -0.7023], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.3053, -7.1347,  0.4386, -1.2137,  1.4402, -1.4629, -5.0046,  0.0829,
        -1.3859, -1.8551,  0.0475,  0.1434, -3.8032, -2.7969, -1.7831, -2.4624,
        -1.7780, -1.0114, -3.1817, -1.9315], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 1.2048, -1.5393,  0.1398, -5.0784, -1.3590,  0.8282, -1.3738,  1.8850,
        -0.9890, -5.8108, -0.3124, -3.1027, -3.4232,  0.0750,  0.0100, -5.1285,
         0.4038, -1.4734, -4.6115, -1.6885], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.0187,  0.3948,  2.7193,  0.4996, -5.6271, -0.5290, -2.6269, -2.0460,
        -3.2039, -1.6431, -3.0822, -1.4138, -1.7075, -5.8131, -1.7243, -1.3095,
         0.8910, -0.4596, -2.3219, -3.2146], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.7238, -1.4351, -1.0550, -5.8185, -2.7914, -6.0794, -4.4597, -1.5737,
         1.6485, -2.6984, -0.2711, -1.1867, -2.6243, -1.6224, -2.8319, -1.3398,
        -5.4392, -0.0970, -1.0112,  3.6951], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.6953,  1.3634,  1.3324,  0.9283, -2.0440, -2.7273, -0.5058, -5.8868,
        -5.4641, -1.5421, -4.3446, -1.8734, -1.2155, -5.7104, -4.5963, -0.7848,
        -0.6126,  2.0580,  0.2726, -4.6275], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ -1.9129,  -2.6905,  -4.6463,  -1.3212,  -2.5615,   1.5184,   0.5520,
         -2.0184,  -0.8730,  -2.5644,   0.4351,   0.4084, -10.6932,  -3.3476,
         -2.2563,  -3.5446,  -4.4407,  -5.2889,  -4.8680,  -4.7189],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-4.7678, -3.3843, -0.8176, -1.5776, -2.4587, -1.8736, -4.6658, -3.5179,
        -4.3020, -5.7116, -8.4183, -2.8393, -2.4832,  1.1375,  0.8609, -2.4836,
        -3.9689, -1.3603, -0.5274, -4.4592], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.8888, -2.3770, -0.9048, -3.4546, -2.6633, -1.6564, -5.0798, -1.9286,
        -0.1657, -1.2291,  0.6235, -1.0417, -4.1914, -2.0592, -3.3533, -3.0722,
        -3.7919, -0.7210, -1.6695, -4.6492], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.4048, -2.6547, -0.0532, -2.9338, -2.4620, -0.1058, -3.2439, -3.1611,
        -1.6197, -0.0735, -5.7837, -1.8693,  1.2864, -1.1103,  0.5145,  0.1359,
        -4.6873, -0.3657, -2.1417, -3.7768], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.2155, -2.7022, -2.6612, -1.4624, -2.6341, -1.5780,  1.2732, -3.2541,
        -0.8837, -1.1370, -2.5557, -0.8316, -1.3488, -4.8027, -3.6510, -1.1348,
        -2.7696, -3.8118, -2.3721, -1.4807], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.6124, -1.5921, -4.3045, -2.5181, -1.9914, -4.4269, -2.0291, -1.1485,
         0.4617, -3.5392, -1.2237,  0.1564,  0.2394, -1.5898, -0.2901, -5.5789,
        -0.1684, -0.4318, -1.3221,  0.2238], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.1862, -4.6602, -1.1533, -0.5157, -1.9154, -0.7295, -1.6418, -4.8243,
        -1.9450, -2.5663, -5.3189, -4.5435, -2.8094, -2.4389, -2.6035,  1.3981,
        -2.0575, -4.8402, -1.4785, -1.5601], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.1771,  0.0993,  1.3421, -3.2591, -1.8695, -1.0747, -1.2201, -3.7653,
        -0.5319,  1.6061, -3.9078, -1.9735, -3.0368, -1.4528, -3.0461, -4.1740,
        -2.6506, -3.5164, -5.6539, -0.8913], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.2192, -1.2689, -3.0054, -1.4718, -0.1572, -4.2859, -3.4928, -0.7149,
        -1.9897, -1.7194, -0.6609, -3.7341, -2.5507, -0.0312, -2.9513, -1.2005,
        -0.6693, -2.8275, -1.0708, -2.2077], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.0508, -3.9329, -1.3853, -1.8410, -4.9034, -1.5393, -0.1602, -3.5189,
        -4.4765, -1.2036, -2.5406, -3.9266, -3.4002, -2.5528, -2.0705, -2.8177,
        -1.4037,  0.5542, -6.0044, -1.4070], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.4121, -2.9692, -1.2717, -2.3347, -4.3555, -1.9278, -1.5032, -3.2602,
        -1.5351, -2.0818, -3.9214, -1.6280, -2.2893, -1.6648, -3.6964, -1.3633,
        -1.5302, -4.6573, -1.9518, -0.5186], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.1023, -4.4129,  0.5301,  0.1347,  3.2053, -3.4842, -5.4216, -1.9532,
        -0.9550, -2.7125, -1.2554, -1.1347, -3.5200, -2.1499, -2.3402, -3.5817,
        -3.1464, -2.0720, -4.2035, -4.2754], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.6001,  1.3550,  0.0398, -4.4147, -1.2676, -1.2281, -1.6098, -4.0647,
        -1.0360, -0.5876, -4.7648, -2.2627,  0.3651, -1.9477, -0.6666, -1.3361,
        -4.6957, -1.4501, -3.3651, -1.1042], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.1255,  1.6386,  0.0267, -4.6512, -0.8750, -4.3959, -2.7966, -1.7428,
        -4.3967, -3.8914, -2.7310, -1.9381, -4.2299, -2.4116, -2.6100, -0.5744,
        -3.8200, -2.9117, -0.9652, -2.0277], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.7650, -0.0176, -4.2214, -1.9137, -2.0354, -1.5708, -2.7039, -3.7638,
         0.7346, -0.7458, -3.1741, -1.8413, -1.5451, -0.1859, -3.5957, -0.9271,
         0.2815, -4.2750, -0.8308, -0.3056], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.3478, -1.4747, -2.8797, -1.5190,  0.0675, -2.3223, -0.3562, -0.4837,
        -5.1272, -1.9163, -2.0761, -2.1915, -2.2672, -0.7746, -0.7405, -4.1993,
        -2.6950, -1.2563, -1.0701, -1.6201], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 0.4369, -1.7381, -2.2795, -0.2806, -0.6892, -3.0103,  0.3109, -0.4060,
        -1.2271, -3.2900, -1.0694,  0.6210, -4.3273, -1.3147, -1.1709, -2.7399,
        -1.9755, -1.6977, -4.8812, -5.3702], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.6145, -2.0688, -3.7399, -2.4167, -0.2093, -4.2416, -3.9166, -0.5115,
        -5.6729, -1.9762, -1.1430, -2.5788, -2.0409, -4.0749, -4.2549, -2.6505,
        -0.1468, -1.9008,  0.4285, -2.9142], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.7739, -2.4594, -3.9080,  1.0103,  1.4920, -0.1931,  0.3530, -2.7217,
        -1.9179, -0.3852,  0.1664, -4.7831, -0.2776, -0.4390, -2.7414, -2.1611,
        -0.3230, -3.1200, -3.8110, -2.1378], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.6852, -4.3892, -6.6380, -3.2036, -0.3481, -1.0932,  2.1610,  0.7611,
        -4.2434, -0.5179, -4.1059, -2.6494, -0.4688, -2.1819, -3.0379, -2.1263,
        -3.0586, -3.7249, -5.8673, -0.2616], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.4044,  0.0283, -3.2510, -0.9780, -5.6524, -5.1116, -6.2542, -0.9910,
        -1.9130,  0.9074, -2.9622, -4.3917, -1.7708, -0.9277, -1.9794, -2.8750,
         3.1574, -3.0028, -3.1273, -2.9389], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.6481,  0.6638,  0.2825, -1.7281, -2.6319, -1.2577, -3.9479, -3.9142,
        -4.9977, -2.5034, -4.8460,  0.4799, -1.0767,  3.5236,  0.4072, -3.8028,
        -0.9945,  0.7566, -1.6524, -0.5410], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.1401, -3.5737, -1.2993, -1.2527, -3.2925, -3.3283,  0.1441, -3.4598,
        -3.5773, -2.2445, -1.3823, -1.6229, -3.2629, -1.2266, -1.1213, -4.4787,
        -2.2380, -1.6693, -2.7454, -4.6608], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.1084, -1.7777,  0.2302, -4.5865, -0.4332, -1.6121, -2.8745, -1.4010,
        -0.6369, -5.5690, -1.8461, -6.0224, -5.0920, -4.0767, -1.8017, -2.6737,
        -4.0945, -1.4273, -2.1778, -3.6757], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.2019, -4.0932, -0.7259, -0.6182, -2.4339, -3.3413, -3.5933, -1.0806,
        -2.9887, -1.8698, -1.7085, -3.0950, -0.9901, -1.2333, -1.5953, -0.5380,
        -0.8092, -4.9045, -2.7163, -2.6968], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.5576, -2.0149, -3.4876, -1.8794, -1.2023, -4.1830, -1.7796, -2.3924,
        -3.5355, -2.9263, -1.0658, -1.1791, -5.0265, -2.4568, -1.0259, -1.8910,
        -0.3605, -1.1586, -4.8205, -2.8823], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.2185, -1.1489, -5.3027, -2.4888, -3.4944, -2.6267, -4.1364, -3.3400,
        -6.3284, -3.9481, -6.0001, -4.7948, -4.7795, -4.4192, -4.5143, -1.3692,
        -3.9152, -3.0311, -1.4640, -4.3411], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.2067, -2.6048, -2.2715, -5.3068, -4.9881, -2.0964, -1.6841, -4.1219,
        -1.8876, -5.4914, -0.3438, -0.8673, -3.5593, -0.4852, -1.0180, -4.3755,
        -3.0079, -1.9574, -1.2624, -1.0298], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 0.9261, -3.6145, -2.1555, -2.5266, -3.9484, -1.5733, -1.7365, -0.9130,
        -1.4505, -5.0167, -1.9311, -1.8239, -0.8751, -3.2334, -0.9348,  0.6263,
        -4.3249, -2.2957, -2.1416, -2.5032], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.4142, -2.4670, -2.7799, -1.4385, -3.0630, -3.3520, -4.9417, -3.7380,
        -2.8827,  0.3275,  0.7140,  2.6147, -1.7528, -5.1583, -0.9070, -1.7557,
        -1.5206, -3.8746, -0.1483, -1.8184], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.8868, -5.9794, -3.9707, -4.1289, -0.7782, -1.6221,  0.8275, -0.5437,
        -3.5128, -1.3099, -2.1371, -1.3734, -3.1474, -2.2802, -4.9048, -2.1658,
        -3.8100, -5.8524, -4.9492, -3.0626], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.4008, -2.7311, -3.9361, -0.1345, -0.9629, -1.9124, -1.1355, -1.2859,
        -0.4320, -5.1557, -0.9728, -0.4344, -3.2801, -1.2946, -0.7628, -1.5359,
        -1.2749, -1.8556, -4.0248, -2.8294], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 1.4114, -0.1864, -3.8030, -1.2930, -0.8587, -1.2812,  0.2571, -1.2830,
        -3.8630, -2.7425, -4.6482, -4.4197, -3.8562, -0.5444, -0.5882,  2.4961,
         0.8791, -3.4048, -1.0127, -0.3601], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.3262, -0.4323, -0.3778, -5.6470, -2.7702, -3.7244, -3.5582, -3.4256,
        -0.5099, -1.1780, -1.5833, -3.2028, -1.4102,  0.4105,  0.3203, -0.0106,
        -4.4770, -1.7700, -0.3191, -4.2568], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.9435, -5.4771, -1.4882, -0.9174, -1.2441, -0.4997,  0.2231, -3.6450,
        -1.3913, -2.2963, -2.2753, -3.8625, -1.2627,  0.1801, -3.8583, -1.7755,
        -1.0237, -3.3947,  0.0452, -0.1491], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.7420, -4.9604, -5.0919, -4.1619, -2.4792,  1.5286,  0.8529, -2.3480,
         1.1289, -1.2062, -0.3764, -2.9011, -1.8694, -2.3251, -4.3736, -1.8913,
        -3.2398, -4.7359, -2.2325, -1.9733], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.2713, -0.3584, -5.0714, -1.9239,  0.5347, -1.8648, -4.7315, -1.8715,
        -3.9467, -4.1400, -3.7420, -5.7085, -3.8836, -3.8256, -2.4576,  0.6088,
         1.1934, -1.3919, -4.7595, -3.9713], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.3615, -1.4825, -0.8795, -2.0516, -3.3069, -1.5048, -1.2064, -1.8504,
        -1.8716, -1.9390, -3.4399, -2.6845, -4.4537, -8.1691, -2.5880, -0.7269,
        -0.3925,  2.7641, -1.2373, -4.0932], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.3329, -0.5943,  0.3140, -2.8246, -1.5098, -1.4074, -2.9341, -1.5605,
        -1.0597, -4.9645, -3.8638, -1.4570, -2.3019, -2.5407, -1.7492, -3.0611,
        -2.3717, -1.8946, -3.4350, -1.2760], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 0.5237, -4.6872, -0.0861, -0.8912, -3.3788, -0.3926, -0.3722, -4.2310,
        -3.0758, -4.5449, -3.7154, -4.8961, -0.4816,  1.7081, -0.1124,  0.7861,
        -3.8890, -1.0944, -0.3873, -2.8987], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.0567, -5.4005, -0.8552, -3.5625,  1.2299, -0.3324, -4.1817, -0.9105,
        -0.5827, -2.7548,  0.2101, -0.2239, -5.2927, -2.3736, -2.5608, -3.4507,
        -4.5274, -0.3953, -2.4662,  2.7500], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-7.2637, -2.3057, -2.9547, -3.8816, -6.7223, -4.2604, -1.1759, -1.4577,
        -0.6254, -0.8703, -4.8600, -2.2221, -1.8114, -3.1441, -2.4961, -0.7204,
        -3.3368, -1.2313, -0.1121, -1.8544], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.5648, -5.2307, -4.9549, -3.4619, -3.0394, -2.7204, -1.5853,  0.9265,
         0.7241, -3.8347, -2.8154, -5.7002, -2.9087, -3.0176, -4.6650, -0.4686,
        -4.8748, -6.0160, -4.7879, -5.9073], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.2527, -1.9221, -2.6466, -3.0984, -2.3167, -2.7983, -1.5003, -2.3312,
        -1.9172,  0.6993, -4.9860, -1.7515, -1.5302, -2.0072, -0.5857,  0.0883,
        -3.8918, -2.7032, -1.5340, -3.5876], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.5097, -2.8753, -1.5250, -2.0955, -5.1132, -0.7677, -1.5361,  0.1138,
        -0.8080, -2.7170, -6.8033, -2.0861, -3.1011, -2.3791, -2.8746, -2.9260,
         0.3501, -2.8075, -0.8118,  0.4585], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.2885, -5.0132, -5.5228, -0.5200, -0.3721, -1.8934,  0.2887, -0.5114,
        -2.8747, -3.1332, -0.6098, -2.2685, -3.8100, -3.1798,  0.0176, -3.7243,
        -1.0218, -1.8527, -2.8308, -0.8559], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.7893, -3.0211, -0.6067, -3.1871, -0.7869, -0.6251, -4.0120, -0.8155,
        -1.3130, -1.5276, -0.0083, -0.2844, -3.6914, -2.0454, -2.6201, -1.5894,
        -1.2091, -3.0652, -2.0259, -1.1977], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-6.2503, -4.8045, -2.1127,  0.1667, -1.9991, -0.1976, -3.9979, -2.7893,
        -3.2730, -2.0147, -3.0341, -2.8045, -1.1367, -5.0763, -0.8724, -1.7787,
        -1.8128, -0.2672, -1.5665, -5.8219], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 8.2558e-01, -3.3425e+00, -3.3801e+00, -2.2431e+00, -2.1346e+00,
         1.8787e-03, -3.0781e+00, -1.3631e+00, -3.9761e-02, -5.2259e-01,
        -2.5092e+00, -3.3263e+00, -1.1864e+00, -5.0370e-01, -5.5042e+00,
        -2.0964e+00, -2.9359e+00, -3.2979e+00, -2.7602e+00, -9.2510e-01],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-0.8893, -1.2339, -5.0564, -4.0879, -0.2398, -2.1395, -2.4768, -0.4526,
        -3.0011, -2.9266, -0.1183, -0.9637, -0.1445, -1.5729, -4.2163, -1.8071,
        -4.1715, -3.8620, -2.1114, -0.6197], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.0739,  1.8502, -4.4269, -1.3670, -1.1703, -3.3350, -2.6725, -2.3619,
        -3.6027, -2.4410, -1.5332, -1.8401, -2.9732, -0.4933, -1.6563, -3.1512,
        -1.4639, -0.1353, -1.9299, -0.2746], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.8202, -2.1288, -2.0753, -3.5037, -0.4203, -1.7947, -3.5770, -1.9828,
        -2.8861, -2.3192, -0.5769, -2.2007, -4.4214, -2.0344, -1.6555, -0.9908,
        -2.2691, -0.7168, -4.9205, -2.2463], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.8452, -3.6966, -0.5940, -2.8124, -3.2211, -0.9096, -1.4595, -4.7998,
        -3.4482, -3.2060, -1.3290, -1.5753, -0.5645, -1.5353, -4.3830, -4.0962,
        -4.1247, -3.4441, -1.9818, -1.4000], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.0806, -1.9063, -4.4833, -4.3956, -4.7974, -0.4609, -1.5535, -2.5675,
         0.3805, -4.8062, -2.1955, -1.6117, -3.6399,  0.0361, -2.5917, -3.2990,
        -3.9903, -2.3810, -3.7084, -3.5280], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.5026, -2.5836, -1.8478, -4.8631, -1.5577, -2.1037, -2.9494,  0.4419,
        -0.1171, -3.7884, -1.0334, -0.8504, -0.3617, -3.3957, -1.9396, -0.1352,
        -4.0161, -3.2927, -1.9105, -2.3924], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.4215, -1.2796, -2.2592, -3.8906,  0.1607, -0.7592, -4.9813,  0.1708,
        -2.0736, -3.4082, -1.3134, -2.8692, -6.1916, -3.2011, -3.0975, -1.1843,
        -1.5602, -0.9685, -4.4065, -1.3760], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.1963, -1.7743, -4.7849, -4.4485, -5.4071, -4.3714, -4.5319, -2.0037,
        -2.5742,  0.2945, -0.0494, -3.1322, -1.8530, -0.8928, -1.4091, -0.6722,
         0.6470, -8.0597, -1.7769, -1.6575], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.9386, -3.6932, -2.1093, -0.7821, -3.4401, -1.1588, -2.0919, -3.7763,
        -3.0247, -2.3900, -3.2181, -1.7988, -0.9442, -5.1563,  0.1454, -2.1381,
        -2.2053, -1.1338, -3.2681, -4.5775], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.2523e+00,  6.9843e-01, -3.9736e+00, -2.9440e+00, -1.4803e+00,
        -2.4546e+00, -3.4180e+00, -9.8151e-01, -2.1482e+00, -3.2107e+00,
        -3.2100e-01, -1.6230e+00, -2.3795e+00,  3.9612e-01,  2.1610e+00,
        -3.5974e+00, -1.6333e+00, -1.6413e-03, -2.2945e+00, -1.0986e-01],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-0.4352, -3.5076, -2.5516,  0.0326, -1.6454,  0.1473, -0.1633, -3.0273,
        -1.6355, -2.8430, -2.6658, -1.8916, -1.0250, -3.8994, -2.5940, -0.4963,
        -3.2254, -4.7730, -0.1387, -3.8507], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.4236, -2.2776, -0.9570, -4.2675, -2.8013, -1.8483, -2.9528, -3.1939,
        -1.0481, -1.1958, -3.3752, -1.8069, -3.2133, -2.3431, -1.3321, -0.5124,
        -4.7119, -3.2871, -1.8344, -3.5951], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.9685, -2.8041, -4.3954, -2.6719, -1.3197, -4.7293, -1.1436, -2.6864,
        -0.9343, -0.3867,  1.0518, -4.9698, -2.6696, -1.3537, -4.6362, -3.0131,
        -1.6753, -0.5832, -3.6513, -0.6475], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.7303, -0.4117, -1.5686, -4.2344, -2.8483, -2.3831, -3.1762, -3.7450,
        -2.2798, -2.2169, -2.1858, -0.6668, -0.6853, -4.0878, -0.9089, -1.5699,
        -4.0623, -1.4619, -3.1683, -1.1763], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.7952, -1.0977, -1.4197, -0.7344,  0.0487, -3.7758, -2.6923, -3.9096,
        -4.5496, -1.1516, -1.8965, -1.9807,  1.3054, -5.3362, -0.4972, -0.5977,
        -2.2549,  0.2018,  0.9203, -3.9238], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.5421, -4.5390, -0.8998, -2.7477, -1.8919, -4.0812, -1.3796, -1.4761,
        -4.1722, -2.5535, -0.2606, -3.9505, -1.8312, -0.4527, -4.2542, -2.0131,
        -0.8821, -2.6911, -3.3872, -2.1512], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.9836, -2.4603, -2.0863, -3.3186, -1.0817,  1.2222, -3.5789, -3.1091,
        -2.6436, -0.9965, -2.9372, -0.8991, -1.2339, -3.9704, -1.4412, -0.2570,
        -2.8258, -1.1567,  0.7693, -5.7376], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 0.1425, -1.8886,  1.4902,  0.5123, -2.9950, -3.0449, -1.5591, -1.7450,
        -0.4890, -0.5068, -7.4221, -1.9289, -2.9180, -6.1521, -6.5003, -4.5442,
        -0.3980, -2.0332,  1.6722, -0.5010], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.4472,  0.4475, -3.3071,  0.1815,  0.5212, -3.4503, -2.4534, -4.9558,
        -5.1241, -4.0548, -5.4241, -0.1441, -2.0186,  2.4444,  1.7273, -3.3781,
        -2.1460, -2.6255, -2.5329, -2.6474], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.9631, -1.6033, -1.4536, -2.5808, -0.6439,  0.4676, -2.1703, -1.8066,
        -2.1257, -2.5704, -2.1580, -0.8517, -5.5175, -3.1398, -1.6948, -3.4632,
        -2.4938, -2.8447, -1.2331, -4.4473], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 0.4693, -1.7378, -5.1390, -3.7082, -5.7196, -5.3712, -3.0628, -0.8639,
        -0.8228,  2.7348, -1.0927, -2.0175, -2.3094, -0.2896, -2.9423, -3.9321,
         1.2018, -5.2271, -2.4193, -2.9530], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.0696, -2.1496,  0.9254,  1.4311, -2.1548, -2.4324, -1.5032, -2.1573,
        -3.7028, -1.2680,  0.4842, -3.5906, -2.4254, -2.7309, -1.9643, -3.0412,
        -1.1857,  0.1074, -3.4954, -2.2607], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.1579, -1.1115, -0.7828, -0.1085, -3.9582, -2.1059, -2.1933, -3.5012,
        -3.7999, -1.9559,  0.3025, -3.7439, -1.6982, -1.4093, -2.8579, -2.8303,
         1.3785,  0.9825, -3.0458, -3.1210], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.0978, -2.6327, -2.1101, -0.3793, -3.1799, -1.6967, -1.5758, -3.7140,
        -1.3892, -0.3416, -3.2689, -2.9169, -2.4073,  0.3153, -4.2711,  0.3861,
         0.7277,  1.2864, -0.6238, -2.2365], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.8809,  2.3356, -1.5706, -3.5986, -1.6735, -0.2779, -0.8401, -1.0036,
        -1.9839, -3.5853, -1.4176, -5.1855, -5.5356, -7.6908, -0.1952, -0.1829,
         1.9526, -0.2059, -4.7981, -0.5704], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 0.5052, -0.5692, -3.8971, -1.2303, -2.7391, -3.6979, -3.2230,  0.2163,
        -2.1914, -3.5904,  0.0713,  0.1132, -0.5298,  1.0599, -1.9178, -5.2193,
        -1.6744, -5.9983, -3.7014, -2.9972], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.5115, -1.9130,  0.2200, -3.6876, -2.4408, -2.6542, -2.0818, -3.3211,
        -1.8986,  1.5585, -5.3085, -2.1074, -2.6306, -0.8082, -3.3435,  0.1111,
         1.3478, -3.7763, -0.6495, -0.4124], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.7362, -1.6122, -1.7266, -0.3849, -2.3875, -1.8827,  0.1900, -4.1281,
        -1.9816, -2.3839, -3.2849, -1.4390, -1.5432, -4.0929, -0.8123, -1.4999,
        -2.8807, -0.7982, -0.0865, -3.6243], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.6506, -2.4065, -5.4252, -3.4443, -1.7508, -0.4148, -2.9062, -0.4586,
         0.2019, -3.2711, -2.6053, -0.4730, -1.8094, -1.7448, -0.1590, -4.0863,
        -1.7363,  1.1450, -1.2910, -1.3840], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.1702, -1.0925,  0.1971, -3.5342, -1.2089, -0.3906, -3.4291, -3.3276,
        -2.6644, -4.0013, -2.7819, -1.0615, -0.2525, -5.2366, -0.6297, -0.6697,
        -0.9011, -1.5877,  0.4844, -3.9159], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-6.1645, -1.3996, -0.3998, -1.1661,  0.2783, -2.0555, -5.5657, -2.2834,
        -3.3912, -3.8808, -1.2972, -1.5120, -1.9789,  0.2895, -4.4231, -3.2158,
         0.1580, -1.5048, -3.4844, -1.2333], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.2672, -0.5050, -2.4993, -3.3073, -0.9961, -0.7410, -4.3625, -2.7484,
        -1.0746, -2.7634, -1.3084, -0.3676, -5.3629,  1.3876,  0.6326, -0.2266,
        -0.9151, -0.6131, -4.8320, -1.8944], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.5580, -3.0352, -6.2316, -4.4069, -2.5372,  0.2853,  1.6596,  4.2592,
        -1.6266, -5.1359, -2.0284, -1.1132, -1.7378, -0.9305,  0.0489, -2.6656,
        -2.6782, -1.6633, -1.2511, -1.7949], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.0635, -1.2775,  0.3806, -4.4478, -3.1368, -2.7282, -3.9899, -2.4814,
        -0.5106, -4.6522, -3.4317, -4.7161, -4.3986, -3.4285, -4.7323, -1.6092,
        -4.3526, -0.6012, -0.6673, -4.2994], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.8876, -2.7982, -3.1018, -0.9539, -1.2431,  2.9646,  0.9845, -3.9359,
        -0.7562, -3.4806, -3.4209, -0.4415, -2.3876, -5.5096, -1.4534, -3.0441,
        -5.3885, -5.0132, -3.1377,  0.3569], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.2560, -3.7710,  0.1075,  1.5376,  1.1644,  1.4720, -5.1993, -2.0770,
        -4.1436, -3.8787, -4.1921, -2.7541, -1.4961, -2.7345, -3.1660, -3.4048,
        -3.5177, -0.1253,  1.4987,  2.8954], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 0.6910, -0.2624,  0.6035, -0.6610, -4.6207, -2.2596, -0.9032, -3.7351,
        -1.3120, -2.3411,  2.4638,  2.0078, -3.3763, -2.5734, -2.6314, -0.0603,
        -3.0772, -0.7992, -2.2548, -3.1686], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.5843, -1.1735, -1.6788, -1.3071, -2.9647, -2.4899,  1.5318, -4.4455,
        -1.3995, -1.3369, -2.1667, -2.0207, -1.5593, -5.1551, -0.4886, -1.7166,
        -0.8826,  1.4270,  2.9919, -4.0462], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.9563, -2.0461, -6.8905, -2.4535, -0.2897, -1.3042,  0.6732,  0.8185,
        -3.7874, -0.9722, -3.7864, -3.4024, -2.8419,  0.5307, -0.4814, -4.3476,
        -1.1529, -2.9501, -1.0186, -1.2235], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.1697, -3.3166, -2.5707, -0.3778, -8.1350, -1.6818, -2.3614, -2.1427,
        -2.2642,  1.5569, -4.0110, -0.2864, -1.5614, -0.5577, -2.2740,  0.0769,
        -5.5292, -1.4137, -1.5740, -2.7051], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.6639, -3.9105, -4.0203, -2.7907, -5.5832, -1.1020,  0.2882, -4.7414,
        -3.4501, -3.1879, -3.3122, -1.5568, -1.6471, -3.6995, -3.0489, -6.2377,
        -3.6907, -3.9620, -1.1667, -2.8168], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.5670, -0.1005,  0.2926,  0.5989, -0.3342, -3.5671, -1.9842, -2.8011,
        -2.9760, -2.5888,  0.8192, -0.5717,  2.4241,  1.3835, -2.8205, -1.6701,
         0.1018, -4.3391, -0.2677,  1.7982], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.3848, -0.8725, -3.1303, -4.4241, -4.1710, -2.8539, -3.2770, -0.8811,
        -0.9626, -2.3574, -0.7116, -1.7494, -1.6169, -0.2230,  0.9614, -4.4040,
        -1.4193, -3.3760, -1.3859, -2.0192], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.7607, -3.4342,  0.3868, -0.8713, -5.0422, -1.3037, -1.4972, -5.0674,
        -1.2199,  0.5720, -2.9148,  0.9002,  1.4445, -3.7867, -1.9551, -0.4599,
        -2.1264, -2.5331,  2.5833,  0.5152], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.2827, -0.5455,  1.5266, -3.7410, -2.3070, -5.4126, -2.4807, -2.5514,
        -1.6797, -0.0284, -3.7576, -1.4724,  0.1842, -3.5768, -3.6241, -2.9806,
         2.2341, -2.8180, -2.7393, -1.1992], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.2063e+00, -4.2538e+00, -1.5423e+00, -1.4618e+00, -2.3311e+00,
        -1.8061e+00,  5.1433e-01, -5.3889e+00,  3.8903e-01, -5.1727e-03,
        -2.0171e+00, -1.6313e+00, -2.5015e-01, -4.8380e+00, -1.5254e+00,
        -4.1816e+00, -3.8279e+00, -3.8464e+00, -4.1813e+00, -1.7314e+00],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-2.5982, -0.4607,  1.1518, -3.0278, -1.7926, -0.4463, -2.2093, -3.1454,
        -0.6691,  0.2632, -4.4769, -2.5138,  0.1614, -2.2035,  0.5602,  1.0818,
        -4.0934, -1.9492, -3.9910, -7.6335], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.6949, -2.3413, -2.5312, -2.9092, -0.1529, -0.6939, -4.8951, -3.1161,
        -1.8842, -4.1231, -0.8539,  1.6104,  4.1057, -0.5874, -4.5317, -0.2716,
        -0.6887, -2.3108,  0.6301,  0.7331], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.0087, -2.5263, -0.7916, -2.0204,  1.5852, -2.9030, -0.4440, -1.1553,
        -1.7335,  0.1777, -1.0717, -3.9969, -3.1838, -4.8936, -4.2034, -0.7257,
         1.6641,  0.3635,  1.4324, -4.7510], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 0.6216, -1.8868, -6.0812, -1.1913,  1.3788, -2.2689,  0.0783,  0.7925,
        -3.9666, -3.7308, -2.7943, -2.4863, -2.7154, -1.1471, -0.7011, -4.8119,
        -1.2531, -0.3788, -2.1808,  1.0340], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.9268, -2.1892,  0.1999,  0.2901, -1.5367, -5.8522, -0.8869, -4.4977,
        -4.5804, -4.2707, -4.4659, -0.8968,  0.5576, -1.6323,  0.2882, -2.4867,
        -3.8253, -5.8110, -5.2126, -1.8698], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.5433, -1.7834, -2.2612, -3.4183, -3.5198, -1.8270, -0.3637, -1.4267,
        -0.2749,  2.6140, -3.7724, -2.2943, -2.8609, -5.2446, -5.1812, -3.1281,
        -3.8996,  0.1429, -2.1612,  1.7453], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.2388,  3.0746,  0.6805, -2.2708, -0.9376, -0.3229, -0.7392, -3.7877,
        -1.3579, -1.3544, -5.8781, -2.1527, -2.0913, -1.9583, -1.6225, -0.4454,
        -3.1999, -2.9466, -0.1478, -1.7518], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.6247,  0.3595, -0.3458,  0.7024,  3.2568, -4.6470, -0.3507, -1.6336,
        -2.8767,  0.0889, -0.8697, -4.0710, -3.3262, -0.7560, -1.5958, -3.5249,
        -1.9031,  1.5122, -3.0363, -1.3548], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.3583,  3.1539, -2.9869, -1.7119, -1.2780, -0.5600, -1.8435, -0.0681,
         1.3233, -2.8406, -0.2773,  0.0779, -2.4995,  1.7747, -0.4077, -4.2668,
        -2.2896, -1.5664, -4.5328, -1.3226], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.0300, -1.3414, -2.6141,  0.5612, -0.4836, -4.6388, -3.0263, -1.0576,
        -1.7988, -1.9685,  0.1831,  1.3894, -4.6299, -1.4049,  0.4355, -0.3877,
         0.3016,  0.1478, -5.6109, -0.7840], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.7481, -2.6189, -3.1266, -1.2155, -0.7927, -3.7065, -0.8221,  0.1272,
        -0.8943, -0.7048, -1.8092, -4.9584, -1.9031, -4.1985, -4.3269, -2.7483,
        -2.1322, -7.6641, -1.4179,  0.7323], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.0674,  2.8417,  2.0017, -3.3517, -0.8777, -1.1154, -2.2590, -2.3428,
        -0.1555, -4.7391, -1.7782, -0.7292, -4.4428, -3.1957, -1.5369, -1.9598,
        -2.5204, -1.7151, -1.0101, -0.2170], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.3434e+00, -4.0331e+00, -5.9118e-02, -1.0866e+00, -3.4456e+00,
         5.6476e-01,  2.0066e-01, -3.8036e+00, -2.5875e+00, -2.5351e+00,
        -2.6593e+00, -2.7428e+00, -6.3494e-01,  3.7479e-03, -4.9539e+00,
        -1.6201e+00,  1.1826e-03, -1.4415e+00, -5.4865e-01,  1.1050e+00],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-2.9048,  1.1432, -1.7418,  3.4254,  3.6609, -3.9578, -0.4129, -2.1244,
        -1.9646, -3.5150,  0.9054, -0.6013, -3.9258, -2.6705, -0.3847, -1.5999,
        -2.0397, -0.5513, -0.1698, -6.2731], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.6347, -0.8316, -0.1429, -0.1314, -4.1594, -2.1551,  0.4883, -3.6019,
         0.7242,  0.1276, -1.7348,  0.7104,  0.2095, -4.9090, -1.6218, -1.6914,
        -3.5998, -2.2449, -1.8736, -0.2043], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.8190, -4.6895, -3.2726, -4.7348,  0.4904, -1.6362, -0.2448, -0.2446,
        -3.4745, -0.7035, -0.1819, -1.9446, -3.7630, -1.3017, -0.6693, -3.8625,
        -3.6410, -2.4752,  0.4934, -3.8038], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.6219, -3.4223,  0.4924, -0.6628, -4.6970, -2.2950, -3.7630, -3.6451,
        -1.1957, -0.2097,  2.1808, -2.4733, -3.3583, -1.1241, -2.0256, -4.1701,
        -0.3917, -0.1073, -4.5712, -3.1598], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.2093, -1.2490, -0.7552, -2.7093, -0.8101, -0.1834, -4.0803, -1.9393,
        -1.5566, -4.4547, -0.7468, -0.5391, -5.6551, -0.3778,  1.0641, -2.6868,
         1.1049,  1.9427, -5.0178, -0.7810], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 1.6979, -1.5104, -4.9932, -2.3908,  0.6344, -0.7030, -3.3365, -0.0753,
         0.4757, -4.1209, -0.8598, -1.9490, -1.9701, -1.8407, -1.3632,  0.7184,
        -4.8395, -3.1801, -2.7325, -2.0487], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.7975, -4.8287, -2.2860, -3.6392, -2.1358, -2.8007, -0.3219, -3.8136,
        -4.5661, -2.1235,  0.5039, -0.4546,  0.9510, -1.2519, -4.6685, -1.0174,
        -1.1763, -2.4814, -1.5595, -0.7331], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.5895, -3.9823, -1.7045, -3.2384, -4.6147, -2.0927, -4.0347, -3.0001,
        -4.0906, -1.9770, -1.5838, -4.4357, -0.2471, -2.0724, -2.3020, -0.1549,
        -3.4229, -5.7561, -1.7254, -5.4166], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 0.0420,  1.1799, -5.1383, -2.2297, -4.8861, -4.3880, -3.9277, -4.0533,
         1.1392,  0.1531,  4.0648, -1.2906, -5.9005,  0.6800, -0.6163, -2.2873,
         1.3362, -2.0715, -2.3812, -3.4151], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.9816,  0.0763, -2.3206,  0.0669, -0.5020, -4.0349, -1.8596, -1.9364,
        -0.5802, -2.0372, -0.5925,  0.9173, -5.3993, -1.5575, -1.2953, -4.1426,
         2.0954, -3.8281, -2.3595, -4.8303], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.7139, -2.0216, -0.8592, -4.0543, -1.7224, -0.5808, -3.8879, -2.1266,
        -2.0165, -3.6806, -0.6601, -1.3095, -2.0950, -2.4533, -0.6949,  0.2869,
        -4.1620, -2.0283, -1.7614, -4.0158], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 0.7540,  1.4985, -4.2597,  0.6189, -0.8234, -2.5141, -0.6354,  1.8059,
        -3.1525,  0.0645,  0.2798, -3.6726, -0.0926,  0.5873, -3.1284, -0.9056,
        -1.8577, -2.0642, -3.4505, -1.3471], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.6607, -2.9744, -3.3784, -0.7239, -2.1088, -4.9354, -2.5309, -4.8076,
        -5.2230, -1.6294, -1.1413,  0.1844,  1.5671, -4.2810, -3.5245, -2.1950,
        -2.7058, -2.2180, -1.1964, -4.6910], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.8222, -0.8958, -0.5367, -3.6027, -4.3177, -0.5367, -2.5498, -4.5159,
        -2.1147, -3.1959, -1.5633, -3.0123, -0.4118,  2.6728, -4.1769, -1.8944,
        -0.7014, -2.1080, -2.9673,  0.0683], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.2342e+00, -1.0009e+00, -5.0170e+00, -2.7804e+00, -1.5693e+00,
        -2.2690e+00, -3.4265e+00, -1.2161e+00,  5.7983e-04, -3.1257e+00,
        -2.9654e+00, -1.8395e+00,  3.6810e-01, -3.5947e+00, -1.5679e+00,
        -1.1305e+00, -4.5342e+00, -8.9683e-01, -2.1542e+00, -2.0867e+00],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-3.5584, -3.1627, -2.0411, -4.2425, -4.6313, -4.3194, -1.9696, -5.0236,
        -1.7839, -5.7294, -1.0900, -1.8184, -5.2928, -3.6919, -3.7539, -2.2705,
        -0.2809, -4.0983, -4.0635, -3.2289], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.7600, -2.9968, -0.8638, -2.1796, -3.3746, -3.0604, -1.9662, -3.4172,
        -2.9885, -0.3943, -3.3093, -2.1259,  0.1107, -4.4990,  0.3454,  0.1499,
        -3.3121, -0.1916,  0.0434, -5.0277], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.3302, -3.2129, -6.0128, -4.7911, -5.0955, -1.3540, -0.6454,  4.1679,
         0.4717, -3.8525, -2.2354, -3.0550, -2.0835, -1.3545, -0.6185, -3.6771,
        -3.5159, -1.1147, -3.3946, -1.0111], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.8199,  0.2642, -2.0142, -3.6940, -0.0055, -1.5517, -4.3636, -1.7052,
         0.6014,  0.0196, -1.0757,  0.6780, -4.5690, -2.2866, -5.0858, -4.4692,
        -1.4532,  1.1066,  1.3953,  0.4433], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.5254, -2.0484, -0.4643, -3.6910, -1.8408, -0.8065, -1.9711, -4.7384,
        -4.4426, -1.6953, -2.9027, -0.1717, -0.6288, -3.2635,  0.0463,  0.8910,
        -3.9166, -2.2392, -2.3934, -1.8918], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.7703, -0.7003, -4.5696, -2.7450, -2.9734, -1.1623, -4.0779, -1.3829,
         0.9253, -5.4496,  1.7947,  0.0438, -2.4641,  1.8106, -1.3545, -4.9375,
        -1.7421, -3.3708, -1.0807, -1.0724], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.6372, -3.4655, -1.7187,  0.8261,  0.1846,  1.3040, -0.6157, -4.6358,
        -1.2496, -3.2220, -2.8033,  1.2579, -2.5129, -2.1021, -2.2664,  0.9548,
        -2.4213, -2.4929, -2.0178, -4.5836], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.4406, -1.5094, -4.7538, -2.1585, -4.4037, -1.7480, -0.6296, -1.0027,
        -3.6416, -1.9447, -3.8201, -3.1824, -1.9789, -1.7059, -5.3266, -1.2179,
         0.2236, -2.6537, -2.1761, -0.3081], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.2272, -0.9112, -3.8627, -2.2780, -1.3033, -4.7222, -1.0024, -1.9278,
        -2.8071, -3.5590,  0.0328,  0.3740, -2.5403, -1.0446, -0.4393, -4.7629,
        -0.1933, -1.1913, -4.8921, -1.6776], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.2243, -1.2954, -1.1593, -2.6122, -1.1935, -2.5604, -2.2016, -1.6561,
        -0.6943, -5.7043, -0.2763, -2.0702, -0.2605,  1.1149, -3.4049, -4.3605,
        -2.8126, -6.4123, -4.7922, -3.2350], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.7629, -1.0399, -4.0429, -3.4672, -2.9525, -2.1173, -2.7093, -0.9121,
         2.3328, -3.7721, -1.6801, -1.9208,  0.1138,  0.7696, -7.0894, -3.5647,
        -2.1720, -4.6190, -4.5591, -3.5796], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 0.9547,  0.8895, -3.5871, -1.1621, -2.5890, -3.8448, -0.5002,  1.7294,
        -5.3857, -1.9136, -0.5668, -0.5313, -2.9334, -1.7399, -0.5406, -4.5760,
        -2.1504, -1.7317, -3.4308, -1.6873], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.5070, -0.5294, -2.6300,  1.2576, -0.2030, -4.7231, -3.4381,  0.0258,
        -2.7051, -2.4155, -1.7493, -3.4859, -0.5069,  0.5770, -0.9077, -1.4667,
        -1.2094, -4.5449, -1.9405, -4.8862], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.0800, -1.8292, -0.9143, -1.5948, -4.0387, -2.7296, -0.9658, -1.3336,
        -6.9322, -4.2670, -2.6526, -6.4820,  1.1225,  0.3495, -2.8296, -2.5155,
        -1.4370, -0.9806, -1.5859, -3.5973], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.0555, -4.0646,  0.8139, -2.1862, -3.2358,  2.8533, -0.6080, -4.5579,
        -0.7398, -2.3559, -1.5154, -0.6226,  0.6505, -3.6937, -1.9076, -4.1607,
        -3.9102, -0.8013, -0.2808, -1.5102], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.0039, -3.6767,  1.8663, -1.2512, -2.6619, -0.3570, -1.3325, -3.2968,
         0.6454, -2.2132, -4.1059, -2.1013, -3.3314, -1.6052, -0.9799,  0.4527,
        -2.1208, -3.8439, -2.2515, -1.6815], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.4635, -2.5892, -1.7580,  0.0702, -5.4773,  0.3494, -2.7621, -0.0171,
        -0.3797, -4.4592, -3.3760,  0.9431, -4.1748, -4.9529, -3.8444, -2.9368,
        -5.1892, -0.3530,  2.1038,  2.1345], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.7998, -3.6895,  0.6766, -1.1406, -1.9506,  0.2786, -0.1983, -4.8904,
        -1.0511, -3.2712, -4.1492, -3.6628, -4.7929,  1.4521,  0.0923,  2.7909,
         1.0389, -3.7591,  0.2319, -0.7804], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 1.0444, -4.6199, -0.2512, -0.6818, -1.9311, -3.7196, -0.6469,  0.4454,
        -4.4998, -2.1133, -1.0716, -1.0796, -1.1176,  1.8162, -3.4299, -1.7747,
         0.8864, -3.3765, -1.1303, -0.4058], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 1.3514, -1.6818, -1.1959, -1.0695, -0.9215,  0.3641,  1.8026, -5.8471,
        -1.4367, -3.4217, -1.1851, -2.7439, -2.4594, -2.3551,  0.8655, -4.9853,
        -1.2378, -1.2573, -1.0121, -3.3965], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.0900, -6.9332, -5.1541, -4.3946, -5.0219, -6.1204, -4.8913, -4.2453,
        -1.6639, -3.0572, -1.2847,  0.8686, -4.4574, -2.6342, -4.6634, -4.6165,
        -4.2029, -4.1696, -2.1704, -4.3962], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.8597, -4.7234, -0.1783,  0.8886,  1.5263,  2.4769, -4.1983, -0.6065,
        -1.2795, -0.0694, -0.5919,  1.1363, -3.7285, -0.9311, -0.7138, -2.4519,
        -2.6305,  0.5598, -2.0736, -3.6765], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.6664, -3.8160, -3.9921,  0.7070,  1.0518,  0.2067,  0.6496, -5.3508,
        -1.4554, -1.3366,  0.0747, -1.8562,  0.7655, -4.5362, -2.0944, -4.4894,
        -2.2136, -1.6269, -2.2918, -5.4782], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.0492, -0.1227, -1.1104, -5.2288, -2.6471, -6.6125, -3.9851, -1.3906,
        -1.0578, -4.2303,  3.3960, -1.7071, -4.3905, -0.4549, -1.2406, -2.2428,
        -0.9872, -0.7691, -3.7276, -2.2429], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.1534, -3.1814, -6.0293, -2.8835, -3.4933,  0.5641,  3.3188,  2.1793,
        -1.7091, -2.1451, -1.7216, -1.7310, -2.8170, -3.7328, -1.7174, -1.3271,
        -4.4555, -0.5944, -4.3100, -5.2837], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 0.9025, -1.0254, -5.4686, -0.1606, -2.3543, -1.3228, -2.2664, -1.1294,
        -0.6067, -4.8385, -2.8018, -0.3460, -1.7315, -4.2093, -1.3649, -1.9092,
        -2.9780, -2.1306, -2.1408, -2.5011], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.6511, -3.0203, -5.5644, -3.7504, -4.3551, -1.0554,  0.0711,  2.5169,
         0.3292, -3.5507, -0.9799, -3.2869, -2.6214, -1.5882, -2.0806, -7.4523,
        -2.1206, -4.2040, -0.8754, -0.0559], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.4132, -3.4184, -4.9458, -5.7487, -3.3073, -3.7188,  0.9270, -3.5850,
        -5.7056,  1.2898, -3.3130, -3.5242, -1.8336, -0.5984, -1.9196, -0.9736,
        -0.6658, -4.7430, -2.1470,  0.2538], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.7298,  0.5802, -2.6245, -5.2211, -1.3096, -4.3731, -5.1096, -3.8370,
        -2.3903, -1.9916, -2.8932,  3.1266, -0.7950, -3.0151, -1.1297, -1.6963,
        -1.3333, -3.6311, -0.3874,  0.2049], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 0.9658, -3.4398,  0.5889, -0.5951, -1.2098,  1.6531, -1.2411, -4.6059,
        -1.1438, -3.5516, -4.5140, -0.5141, -3.1240, -1.7457,  2.8452,  2.7754,
        -4.5042,  0.0923,  1.1400, -0.8575], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.7217, -0.0366,  0.8462, -4.3221, -1.1371, -2.1261, -1.7713, -0.7030,
        -0.7732, -3.1102, -1.6517,  0.1060, -2.8631, -3.5206, -0.3454,  2.0769,
        -5.1306, -0.4210,  0.6028, -1.5454], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.3843, -3.6979,  0.7740, -0.7829,  2.3757,  1.5136, -2.7202, -0.1031,
         0.5460, -2.9378, -0.0673,  0.7620, -4.2814, -2.6665, -1.2470, -1.3628,
        -2.4328, -1.4008, -0.0803, -3.8418], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.6914, -1.8739, -2.2227, -1.3149, -0.9604, -3.4187, -0.1911, -0.5661,
        -2.0565,  0.9805, -0.1546, -4.6176, -1.0921, -1.0089, -2.1906, -1.2306,
        -0.2778, -4.8329, -0.0638,  1.2855], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.4190, -2.2492, -3.0441, -0.0397, -0.2390,  3.5508,  0.0327, -5.5981,
        -1.1446, -2.1468, -1.5069, -2.9710,  0.4817, -1.5653, -5.5332, -1.9703,
        -2.1499, -2.3968, -5.7933, -1.9771], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.2965,  0.1293, -3.0913, -4.3233, -0.7204, -1.9338, -4.5010, -4.2967,
        -1.5385, -1.8826, -1.1532,  0.8862,  2.0284, -3.5746, -1.6226, -0.9701,
        -1.3471, -0.8626, -0.3343, -3.6400], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 0.6433, -3.8178,  0.1009, -1.4635, -2.1462, -3.8919, -0.0145, -0.5823,
        -4.4456, -0.8548,  0.1013, -0.0331, -0.7335, -0.8935, -4.3498, -1.6883,
        -1.8461, -1.5563, -1.3999, -3.2072], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.4092, -1.0457, -0.2950,  0.4204, -4.4146, -1.9492, -4.6368, -3.0260,
        -2.0397, -0.5497,  3.6619,  2.1788,  1.5444, -3.5609,  0.2825, -0.1859,
        -0.9488,  0.0961, -0.1702, -4.8681], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.3077, -4.3228, -3.5932, -1.2635,  0.2254, -2.5523, -1.2283,  1.1297,
        -2.3336,  0.2044,  0.8405, -2.9898, -2.0638, -2.9059, -1.2452, -3.2265,
        -0.9781,  0.2066, -3.3473, -0.4930], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-8.3633e-02, -2.4937e+00, -4.8094e+00, -9.2627e-01, -7.0277e+00,
        -6.0624e+00, -4.8521e+00, -2.7938e+00,  1.0471e-03,  1.3260e+00,
         4.3188e+00, -1.1137e+00, -6.4576e+00, -5.9115e-01, -1.4005e-01,
        -6.2929e-01, -3.9230e-01, -1.4975e+00, -4.4174e+00, -1.7337e+00],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([-3.2435, -1.0280, -0.3450, -1.6322, -2.2147, -1.2420, -0.4615, -4.9251,
        -1.6150,  0.9362, -2.7666,  0.2013, -0.6940, -3.1425, -4.1579, -1.1658,
        -1.1183, -0.4749, -0.1172, -4.0247], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 0.0782,  0.9069, -0.4532, -3.1499, -3.1392, -1.4898, -0.3804, -3.6606,
         0.6539, -1.4435, -4.3909, -1.2904, -1.6321,  0.1508, -1.5546, -1.7945,
        -5.1675, -1.8548, -0.9560, -3.4792], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.3788, -0.3259, -0.9956, -2.4738, -2.5503, -0.2016, -1.3967, -3.4531,
        -2.3486,  0.9209, -2.5968, -3.0411, -1.1627, -2.5321, -2.5708, -1.4222,
         1.1738, -4.4022, -3.6910, -6.6261], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-5.8299, -1.1605, -0.1861, -3.2961, -1.6415, -1.6798, -4.4882, -1.2712,
         0.3751, -2.6281,  1.2572, -1.4911, -6.9132, -3.3256, -6.6191, -4.8501,
        -1.8790,  0.5115,  1.3583, -0.1297], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.4657, -2.7738, -5.0009, -0.7223, -1.7029, -0.0576, -1.3731, -3.7258,
        -2.5406, -2.0220, -2.4734, -1.1135, -0.9435, -5.0722,  0.6842, -1.0173,
        -3.0018,  0.3325, -3.5861, -5.0277], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.8520, -1.2311, -2.3260,  0.0752,  1.1957, -2.5070, -0.2970,  1.1026,
        -2.2591,  0.4548,  1.3052, -2.6782, -2.6496, -0.3106, -4.4800,  0.4443,
         1.0534,  2.8190,  3.6350, -5.4599], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.1732, -2.4384, -0.1315, -3.4259, -1.8888,  2.1966, -5.6275, -0.2523,
        -0.8980, -3.7937,  0.2145,  1.4709, -4.4378, -3.1615, -2.3056, -3.4611,
        -5.5703,  1.1375,  1.0429,  1.0753], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.1070, -5.2575, -0.2570, -0.7990, -2.6200, -3.6716,  1.0424, -2.4204,
        -6.2574, -3.1383, -1.2209,  0.1577, -0.5605,  1.8646, -3.7102, -2.3245,
        -3.1857, -1.8693, -2.9486, -0.5722], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.2493, -2.5987, -0.2021, -0.4302, -4.0138, -0.2982, -2.6301, -1.9099,
         0.1874, -2.2115, -4.4909, -2.3340, -2.3427, -4.6572, -2.8602, -4.2006,
        -0.8582,  1.2042, -2.4705, -1.8459], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.0243, -1.1386, -0.7726, -4.7296,  1.0014, -0.1351,  0.2507,  1.7098,
        -0.4766, -4.2789, -2.1037, -4.8459, -3.6991, -3.8821,  0.7232, -0.4739,
         1.5273,  2.8346, -5.3408, -1.5434], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.3791,  0.1947, -2.0976, -0.5315, -0.4738, -3.6280, -2.0922, -1.8676,
        -2.1730, -3.3952, -0.5771,  1.7520, -3.4302, -2.1978, -0.9344, -2.6080,
        -1.1067,  0.2851, -4.4547, -0.0698], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.3569, -4.0077, -2.9320, -2.1420, -0.5549, -5.2156,  0.8445,  0.5537,
        -4.2491,  1.6376, -1.6236, -3.4369, -2.3576, -4.5072, -2.2188, -3.0663,
        -1.0249, -1.0846,  1.0227,  0.4243], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.1533, -3.8829, -2.7647, -0.3555, -1.5978,  0.1081,  2.5372, -5.1120,
        -1.4769, -2.8266, -0.5222, -2.7158, -0.7405,  1.4489, -5.1300, -0.7777,
        -0.3897, -1.7989,  0.0799, -1.7873], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.3916e+00, -1.2361e+00, -3.4588e-01, -4.5428e+00, -1.3056e+00,
         5.9986e-03, -1.3138e+00, -1.5564e+00,  2.2928e-01, -6.0577e+00,
        -1.9155e-01, -1.5264e+00, -1.6261e-01, -1.2343e+00, -1.1069e+00,
        -3.9275e+00, -3.0153e+00, -1.4321e+00, -1.1978e+00, -3.5585e+00],
       device='cuda:0', grad_fn=<SubBackward0>)
tensor([ 1.1904, -2.0464, -1.7607,  1.1749, -4.2027, -0.7765, -0.5988, -2.2526,
        -0.4361,  1.6061, -5.9245, -1.0771, -0.5295, -0.0392, -3.1334,  0.3363,
         1.6626, -2.5527, -2.5430, -4.2734], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.1690, -1.6217, -3.1687, -3.3168, -3.2419, -1.0503,  0.0961, -3.2601,
        -1.8807, -2.8471, -2.0408, -1.0634, -0.6126, -5.6737,  0.5946,  0.0889,
        -1.7778,  1.3542, -0.2469, -5.5093], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.0281, -1.9715, -0.5883, -1.0317, -5.7145, -3.5553, -1.8047, -1.3242,
        -3.0050, -1.7668, -3.3309,  2.1396,  0.0472, -3.5617, -3.4276,  3.4831,
        -1.9783, -0.5478, -0.2966,  0.0755], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.9259, -3.0407, -0.7583,  0.8106, -3.2611, -3.0450, -0.4528, -1.3797,
         1.9984,  0.9352, -3.8076, -1.1015, -0.9502, -1.0484, -2.5684, -1.2476,
         1.0473, -4.2810, -1.9355,  0.0398], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.2539, -5.4287, -4.3655, -5.3219, -2.4764, -5.1333, -3.6185, -4.6431,
        -1.5635, -0.8394, -4.1404, -3.0513, -1.7505, -4.6271, -2.5813, -1.3597,
        -4.2230, -2.5222, -5.4720, -4.4604], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.9603, -4.1788, -4.1427, -4.6146, -3.9960, -1.8488, -2.1880, -4.6949,
        -4.0962, -4.7270, -4.4759, -3.8989, -1.5857, -1.1019,  0.8738,  1.5127,
        -5.3529, -3.4704, -4.5532, -4.9689], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.6034,  0.1421, -5.8637, -2.0063,  0.3567, -0.0079,  1.1351, -0.3057,
        -4.2016, -2.3009, -6.8892, -3.5648, -3.8973, -1.2367,  2.5147,  0.0688,
         0.7295, -2.9493, -2.8025, -5.0612], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.2273, -3.3143, -1.5379, -3.4173, -3.1749, -2.2220, -0.0308,  0.9906,
        -5.6381, -1.4468, -1.5879,  0.1280,  0.3940,  1.4841, -4.2718, -2.0748,
        -5.7198, -6.0041, -2.9359, -3.4940], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.5546, -0.8860, -2.7268, -0.3670, -1.3608, -4.8315, -2.6378, -0.6506,
        -1.1173, -1.6462, -0.5206, -1.2555, -4.2308, -2.4291, -1.7083, -0.4898,
        -2.7387, -1.1594,  3.0299, -4.3825], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.2146,  0.5719, -2.6176, -0.9601, -0.2056, -2.9957, -1.4587, -1.5437,
        -1.7820,  0.5126,  1.1441, -5.5121, -2.1575, -3.8693, -3.9552, -2.0282,
        -1.2513,  0.2868,  0.1292, -1.4947], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.3947, -2.1944, -1.8859, -1.7042, -2.2536,  0.3973,  0.7579, -2.4196,
        -2.7023, -3.4665, -5.0306, -2.7159,  0.1120,  0.6992,  2.9509, -1.5818,
        -4.2426, -0.4000,  0.0999, -0.7266], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-2.3018, -2.6703, -0.8666, -0.3030, -6.7311, -1.9127, -3.8746, -4.2997,
        -0.3212, -4.4292, -4.1220, -0.6435,  1.6277, -3.8281, -2.2643, -0.1036,
        -3.4785, -0.4728,  0.8535, -5.4345], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 0.4674, -2.0436, -1.2370,  1.1768, -2.6994, -2.2459, -1.2581, -3.2114,
        -2.3534, -1.8400,  0.4223, -2.4351, -1.4254,  0.4343, -1.3380, -4.0460,
        -1.2404,  1.4606, -4.3949, -0.8527], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.4502, -2.8130, -3.0728, -3.6966, -4.9138, -1.3367,  0.0390, -2.8470,
        -1.5620, -1.1228, -3.6692,  0.7989, -1.8231,  1.0724, -3.4732, -3.1516,
        -1.3538, -4.2290, -0.3569, -1.8905], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.6782, -2.4175,  0.2082,  1.0233, -3.7752, -2.4343, -0.5012, -1.8670,
        -2.8398,  1.5581,  2.2512, -3.8452, -1.0579, -1.4428, -1.1161, -2.2607,
        -0.4939,  0.0228, -2.3182, -1.2326], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.8773, -2.5791, -1.5066, -3.4039, -0.7908, -2.1651, -4.8938, -0.5445,
         2.1876, -1.2330,  0.1002, -0.1970, -5.5750, -1.6056, -0.2033, -2.3819,
        -2.5451, -1.3923,  0.0546, -3.8029], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.5011, -4.3834,  0.6470, -2.5027, -1.4112, -0.5957, -0.3280, -0.6796,
        -2.8001, -2.0947, -0.0167, -5.0472, -0.3996, -0.8249, -0.0714,  0.5129,
        -1.9848, -6.2325, -1.2721, -5.9823], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-4.2390, -2.3491, -2.1948, -4.8981, -4.4469, -3.5348, -0.2354,  1.3016,
        -3.4548,  2.2237, -2.1848, -3.9437, -4.2172, -3.4632, -3.5914, -0.1334,
        -0.5794, -0.4799,  1.6571, -1.4668], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.3843,  0.4808, -2.3689, -3.4983, -1.4458, -3.3645, -1.8290, -2.0822,
         0.0178,  0.4018, -4.9286, -1.7640, -0.8257, -2.6507, -0.7449,  0.3626,
        -4.9763, -2.7277, -3.8972, -0.9847], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.0963,  0.0773, -2.9850,  3.0080,  1.1414, -3.7071, -0.0405, -1.1924,
        -1.7287, -2.5415,  2.1932, -0.4566, -3.0824,  0.3070,  0.4511, -2.6080,
        -1.3771,  0.8811, -4.0702, -0.0940], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.0133,  0.1814, -1.0209,  1.0680, -5.4431, -1.0781, -0.3978, -2.6203,
        -1.7661, -0.8233, -3.9454, -2.4685, -0.2556, -4.1046, -2.9978, -0.8759,
        -0.4971, -4.2188, -0.5335,  0.5355], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.7619, -5.9591, -2.4448,  0.5934, -2.3274, -4.9842, -1.1913, -3.2583,
        -4.2033, -2.9444, -0.9533, -3.9280,  0.2843, -1.3784,  1.5526, -0.6286,
        -3.3490, -0.0385, -0.9141, -1.1119], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-0.1052, -3.1004, -3.8868, -0.6167, -0.7498, -1.3303,  0.8346, -0.5046,
        -4.2283, -2.7443, -1.9351, -1.0117, -1.4662, -1.3013, -4.0868, -0.1767,
        -1.1639, -1.5768, -0.2339, -1.4478], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-1.0925,  0.3425, -3.0019, -1.9283,  2.4387, -3.9316, -0.8717, -1.4578,
        -1.4416, -1.5188, -1.4775, -5.1663, -1.6720, -0.0344, -0.1232, -0.3151,
        -0.3337, -5.5314, -2.8685, -4.4524], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 0.9904, -3.9605, -0.6307,  0.8829, -2.4736, -0.6244,  0.6144, -3.6941,
         0.4188, -0.6981, -1.8003, -3.7739, -1.5105,  1.7333, -3.1917, -2.1186,
        -2.0783, -2.2487, -1.3136,  0.0929], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([-3.4277, -1.6094, -1.2905, -1.6920, -1.9039, -0.4205, -3.7433, -3.6222,
        -1.6371, -1.1592, -3.6180, -2.1060,  0.0915, -4.2423, -2.3264,  0.8086,
        -1.7377, -0.4973,  0.4596, -5.4942], device='cuda:0',
       grad_fn=<SubBackward0>)
tensor([ 1.0488, -4.8850, -2.2076, -0.8255, -1.7839, -2.6015, -0.3426, -1.9323,
        -3.3982, -1.2674, -0.9787, -3.4807,  0.1672,  0.3401, -2.4578, -2.1398,
        -3.3843, -3.7366, -4.5899, -0.3589], device='cuda:0',
       grad_fn=<SubBackward0>)
