Iter #50: tensor([[-0.1576, -0.0718],
        [-0.1982,  0.0593],
        [-0.0774,  0.1656],
        [ 0.0213, -0.0718],
        [-0.0454, -0.0837],
        [-0.0159, -0.1074],
        [-0.0653, -0.0600],
        [-0.0033, -0.0610],
        [-0.0034,  0.0125],
        [-0.0734, -0.0847],
        [-0.2000, -0.0090],
        [ 0.0091,  0.0220]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-0.0119, -0.0104],
        [-0.0209, -0.1083],
        [-0.0340, -0.1077],
        [-0.1154,  0.0404],
        [ 0.0428,  0.0201],
        [ 0.0235, -0.1144],
        [-0.0294, -0.0388],
        [-0.0387, -0.0492],
        [-0.0523,  0.0463],
        [-0.0312, -0.0097],
        [ 0.0469, -0.1987],
        [ 0.1091, -0.0972]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[ 0.1161,  0.0608],
        [-0.0493, -0.1063],
        [-0.0042,  0.1218],
        [-0.0175, -0.1050],
        [-0.0947,  0.0136],
        [-0.2563, -0.0265],
        [ 0.0700, -0.0124],
        [ 0.0338, -0.1057],
        [-0.1163, -0.0786],
        [-0.1052, -0.0332],
        [-0.0261, -0.0734],
        [-0.1257,  0.0351]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[ 0.0216,  0.0390],
        [-0.0456, -0.0845],
        [ 0.2115, -0.0460],
        [ 0.0642, -0.0199],
        [-0.1079, -0.0071],
        [-0.0428, -0.0374],
        [ 0.0746, -0.0590],
        [-0.1279,  0.0194],
        [-0.1016, -0.0130],
        [-0.1352, -0.0734],
        [ 0.0187,  0.0328],
        [ 0.0300, -0.0473]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[ 0.0760,  0.0793],
        [ 0.0673,  0.0275],
        [ 0.1485, -0.1325],
        [-0.0059, -0.1122],
        [ 0.0956,  0.0319],
        [-0.0641, -0.0633],
        [ 0.2224, -0.0978],
        [-0.0536,  0.0480],
        [ 0.1654, -0.0146],
        [ 0.0121, -0.0593],
        [-0.0421, -0.0429],
        [ 0.0250,  0.0156]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 0.0949,  0.0006],
        [ 0.0550, -0.0769],
        [ 0.2849, -0.0956],
        [ 0.0214, -0.0255],
        [ 0.2520, -0.1550],
        [-0.1627,  0.0470],
        [ 0.1592, -0.0856],
        [-0.1439, -0.1063],
        [ 0.0467,  0.0337],
        [ 0.0214,  0.0447],
        [-0.0555, -0.0370],
        [-0.1589,  0.0115]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 0.0210, -0.0235],
        [ 0.1571, -0.1278],
        [-0.1434,  0.0164],
        [-0.0054,  0.0150],
        [ 0.0326, -0.0569],
        [ 0.2100,  0.0350],
        [-0.1049, -0.0047],
        [ 0.1828,  0.0086],
        [ 0.0172, -0.1299],
        [ 0.0781,  0.0404],
        [ 0.0445, -0.0855],
        [ 0.2339, -0.2649]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[ 8.9032e-02, -4.1380e-02],
        [-1.6556e-01,  1.7719e-01],
        [-1.6385e-01,  1.7266e-02],
        [ 1.5839e-01, -6.9812e-03],
        [ 6.6887e-02, -5.2096e-02],
        [ 1.0904e-01, -5.0055e-02],
        [ 1.4926e-01, -1.5567e-01],
        [ 2.9535e-02, -1.3686e-01],
        [-6.2583e-02, -3.0196e-02],
        [ 1.3500e-04,  4.5663e-02],
        [ 6.9665e-02, -2.7306e-01],
        [ 6.4207e-02, -2.0218e-02]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[ 0.0268,  0.1519],
        [-0.2710,  0.1061],
        [-0.2652,  0.2109],
        [-0.0060,  0.0088],
        [-0.0824,  0.0875],
        [-0.0466, -0.0045],
        [-0.2032,  0.2070],
        [-0.0817,  0.0108],
        [ 0.0305,  0.0414],
        [-0.0777, -0.0473],
        [-0.0102, -0.0504],
        [-0.0034,  0.0488]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[ 0.1334, -0.0204],
        [-0.1177,  0.0009],
        [-0.0346,  0.0241],
        [-0.0701, -0.0023],
        [-0.0424, -0.0237],
        [ 0.0097, -0.0608],
        [-0.0825, -0.0687],
        [-0.0170, -0.0134],
        [-0.0842,  0.0079],
        [-0.0902, -0.0526],
        [-0.0635,  0.1088],
        [ 0.0474,  0.0142]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-0.0601,  0.0217],
        [-0.0695, -0.1004],
        [-0.0555,  0.0575],
        [ 0.0105, -0.0611],
        [-0.0537, -0.0875],
        [-0.1978,  0.0858],
        [-0.2604, -0.1009],
        [-0.1901, -0.0110],
        [ 0.1649, -0.0598],
        [ 0.1154, -0.1135],
        [-0.2360,  0.1523],
        [ 0.1086, -0.1820]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-0.0382, -0.0008],
        [ 0.0297, -0.1412],
        [ 0.0157, -0.0960],
        [-0.1541, -0.0786],
        [-0.0179, -0.0348],
        [-0.1137, -0.1584],
        [-0.0162, -0.1894],
        [ 0.0110, -0.0024],
        [-0.0910,  0.0292],
        [-0.1124,  0.0233],
        [-0.0889, -0.0545],
        [-0.0846,  0.0191]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-0.2964,  0.1833],
        [-0.0793,  0.0176],
        [-0.0204,  0.0050],
        [ 0.1663, -0.0269],
        [ 0.1338, -0.0612],
        [-0.0315, -0.0439],
        [-0.0414, -0.2172],
        [ 0.1528, -0.0633],
        [ 0.2298, -0.1680],
        [-0.0020, -0.0842],
        [ 0.0612, -0.2552],
        [ 0.1504, -0.2702]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-0.1974,  0.0042],
        [-0.2622,  0.0930],
        [-0.1028, -0.0351],
        [-0.0216, -0.2149],
        [ 0.2359, -0.1197],
        [-0.0281, -0.1926],
        [ 0.0262, -0.1439],
        [ 0.2770, -0.4334],
        [-0.0907, -0.0591],
        [ 0.0709, -0.2644],
        [-0.1693, -0.1041],
        [-0.1259,  0.3100]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.2564,  0.0005],
        [ 0.0041, -0.0850],
        [ 0.0775, -0.1299],
        [-0.1119, -0.1476],
        [-0.0094, -0.1437],
        [-0.4519,  0.1041],
        [ 0.0016, -0.0949],
        [-0.0596, -0.0931],
        [ 0.0476, -0.2412],
        [-0.1552,  0.0479],
        [-0.1521,  0.1218],
        [-0.2032, -0.0120]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[ 0.3632, -0.1901],
        [ 0.2004, -0.2107],
        [ 0.2301, -0.2333],
        [-0.0443, -0.1566],
        [-0.1325, -0.1365],
        [-0.3286,  0.0327],
        [ 0.1613,  0.1133],
        [ 0.1317, -0.2056],
        [ 0.1593, -0.2416],
        [-0.0101, -0.0923],
        [-0.2787,  0.1218],
        [-0.3504,  0.0856]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 0.2954, -0.2597],
        [-0.3702, -0.0248],
        [-0.0352, -0.1130],
        [-0.1399, -0.0958],
        [ 0.2546, -0.4089],
        [ 0.1424, -0.1790],
        [ 0.2311, -0.2742],
        [ 0.1681, -0.2305],
        [ 0.2171, -0.2823],
        [-0.1358,  0.0506],
        [-0.0954, -0.0904],
        [-0.0979, -0.1891]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 0.1945, -0.2961],
        [ 0.0503, -0.1193],
        [ 0.0477, -0.0310],
        [-0.1476, -0.0071],
        [-0.0420, -0.0088],
        [ 0.1935, -0.1418],
        [-0.2378,  0.0413],
        [ 0.1100, -0.1001],
        [-0.2192,  0.1012],
        [ 0.0563, -0.2192],
        [-0.2227,  0.1165],
        [ 0.2593, -0.4942]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[-0.1984,  0.1455],
        [-0.4314,  0.0230],
        [ 0.1299, -0.2460],
        [ 0.1146, -0.0796],
        [ 0.1845, -0.2852],
        [ 0.0415, -0.0947],
        [-0.1851,  0.0321],
        [-0.0863, -0.1140],
        [-0.0220, -0.3304],
        [-0.3842,  0.3070],
        [-0.3006,  0.1843],
        [-0.0506, -0.1781]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-0.2899,  0.1417],
        [-0.2003,  0.0208],
        [-0.2747, -0.0255],
        [-0.1401,  0.0181],
        [ 0.0466, -0.1615],
        [-0.4105,  0.2309],
        [-0.1095, -0.0542],
        [-0.3934,  0.0345],
        [ 0.4133, -0.5147],
        [ 0.3989, -0.5722],
        [ 0.0466, -0.3485],
        [-0.0331, -0.0700]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-0.2187,  0.1297],
        [ 0.0014, -0.0650],
        [-0.0468, -0.0164],
        [-0.3914,  0.0359],
        [ 0.0066,  0.0267],
        [ 0.4954, -0.3288],
        [ 0.0191, -0.2570],
        [-0.0461, -0.2157],
        [ 0.0159, -0.0562],
        [ 0.0425, -0.2383],
        [ 0.5172, -0.2951],
        [-0.0331, -0.2709]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-0.0392, -0.1896],
        [-0.1595, -0.0759],
        [-0.0897, -0.0784],
        [-0.1993,  0.1984],
        [-0.2407, -0.0073],
        [-0.2630,  0.0418],
        [ 0.0034, -0.2298],
        [ 0.0139, -0.1941],
        [-0.2299,  0.0241],
        [-0.3108,  0.1072],
        [-0.4590,  0.0287],
        [-0.0005, -0.0803]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-0.0793,  0.0832],
        [-0.2384,  0.2363],
        [-0.1772,  0.0603],
        [-0.2918,  0.0100],
        [-0.3706,  0.2439],
        [-0.5068,  0.1756],
        [-0.1972, -0.0569],
        [-0.0387, -0.0712],
        [-0.1045, -0.0856],
        [-0.3281,  0.2089],
        [-0.0847,  0.0408],
        [-0.0379, -0.0019]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-0.2461, -0.0498],
        [ 0.0640, -0.0896],
        [-0.0820, -0.0517],
        [ 0.1096, -0.1696],
        [-0.1032, -0.1752],
        [-0.1116, -0.0644],
        [-0.0636, -0.0654],
        [-0.1108, -0.0061],
        [ 0.0099, -0.0733],
        [-0.1569, -0.1264],
        [-0.3798,  0.2438],
        [-0.0956, -0.0430]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-0.2387,  0.0643],
        [-0.4046,  0.1902],
        [-0.0931, -0.0214],
        [-0.0757,  0.0026],
        [-0.3228,  0.1157],
        [-0.3008,  0.0091],
        [ 0.3675, -0.4868],
        [ 0.2845, -0.3411],
        [ 0.0390, -0.2671],
        [ 0.1788, -0.1644],
        [ 0.1343, -0.2177],
        [-0.0289, -0.1229]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.3067, -0.0986],
        [-0.2106, -0.0744],
        [-0.3061,  0.2085],
        [-0.4426,  0.1893],
        [ 0.0537, -0.1857],
        [-0.3879,  0.1775],
        [ 0.1441, -0.2221],
        [-0.0772, -0.0908],
        [-0.1251,  0.2397],
        [-0.0919, -0.1904],
        [ 0.3604,  0.0273],
        [-0.0869, -0.2666]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[ 0.0033, -0.2948],
        [ 0.1014, -0.0955],
        [ 0.5708, -0.5103],
        [ 0.3117, -0.5713],
        [-0.1798, -0.1580],
        [-0.1676,  0.1535],
        [-0.2492,  0.1115],
        [-0.0302, -0.2332],
        [ 0.0059, -0.0924],
        [ 0.2199, -0.2406],
        [-0.3191,  0.0074],
        [ 0.3310, -0.4111]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[-0.2533,  0.1670],
        [ 0.0670, -0.1639],
        [-0.1504,  0.0387],
        [ 0.1563, -0.3199],
        [ 0.3522, -0.4599],
        [-0.1998,  0.1547],
        [ 0.0615, -0.0355],
        [ 0.1098, -0.0949],
        [ 0.2219, -0.2058],
        [-0.0464,  0.1768],
        [-0.4904,  0.2179],
        [-0.1034, -0.3677]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[-1.5880e-01, -1.5251e-01],
        [-2.7609e-01,  1.7519e-01],
        [-3.4400e-01,  3.2199e-02],
        [-8.5736e-02, -5.7460e-02],
        [ 1.4519e-04,  9.0908e-02],
        [ 2.9025e-01, -1.6800e-01],
        [-3.5740e-01,  3.9526e-02],
        [ 2.2142e-02, -1.2726e-01],
        [ 2.1989e-01, -2.2116e-01],
        [ 1.4860e-01, -2.2441e-01],
        [-6.2467e-02, -2.0131e-01],
        [-2.0738e-01, -1.3850e-02]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[ 0.5625, -0.1796],
        [ 0.1049, -0.3471],
        [-0.1072, -0.0011],
        [ 0.5770, -0.3988],
        [-0.1551,  0.1386],
        [-0.0440,  0.1511],
        [-0.1095, -0.2290],
        [-0.1059, -0.0197],
        [ 0.0160,  0.0200],
        [-0.3645,  0.1824],
        [-0.2791,  0.0409],
        [-0.0116, -0.1285]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-0.1782,  0.0400],
        [ 0.0340, -0.0814],
        [-0.4832,  0.4252],
        [ 0.0089, -0.0922],
        [-0.1743,  0.2497],
        [-0.2999,  0.0242],
        [ 0.0844, -0.2702],
        [-0.3689,  0.1728],
        [ 0.1861, -0.1567],
        [ 0.2219, -0.2808],
        [ 0.0933, -0.1710],
        [-0.0582,  0.0919]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[ 0.2326, -0.0703],
        [-0.1793,  0.1468],
        [ 0.4525, -0.2353],
        [-0.0912, -0.1112],
        [-0.2318,  0.3424],
        [-0.1000,  0.1642],
        [-0.4951,  0.1237],
        [-0.3915,  0.2108],
        [-0.5312,  0.3119],
        [ 0.1497, -0.1089],
        [ 0.1096, -0.0954],
        [-0.1639,  0.0659]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[ 0.0469, -0.3265],
        [-0.1415,  0.0049],
        [-0.1895,  0.2474],
        [-0.0496,  0.0997],
        [ 0.0568, -0.2033],
        [-0.3359,  0.0991],
        [ 0.1232, -0.2979],
        [-0.4584,  0.2426],
        [ 0.0747, -0.1395],
        [ 0.0390, -0.0762],
        [ 0.0637,  0.1713],
        [-0.1662,  0.1538]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-0.0501, -0.0060],
        [-0.3192, -0.0622],
        [-0.3943,  0.3249],
        [-0.2589,  0.1921],
        [ 0.2259, -0.1121],
        [-0.1015, -0.0031],
        [-0.0872, -0.0532],
        [-0.3902,  0.3492],
        [ 0.0667, -0.0473],
        [ 0.3360, -0.1236],
        [-0.0933,  0.0808],
        [ 0.0343, -0.0090]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-0.0493,  0.1480],
        [-0.1254,  0.0904],
        [ 0.1265, -0.1133],
        [-0.2678, -0.0296],
        [ 0.1858, -0.1749],
        [ 0.4863, -0.0518],
        [-0.0490,  0.0742],
        [-0.3294,  0.2807],
        [ 0.0048, -0.1228],
        [ 0.0093, -0.0254],
        [-0.4420,  0.1955],
        [-0.0575, -0.0544]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-0.1702,  0.2230],
        [-0.5198,  0.0911],
        [-0.1309, -0.1231],
        [-0.1672,  0.0209],
        [-0.5263,  0.3475],
        [-0.1650,  0.0285],
        [-0.3654,  0.0528],
        [ 0.1360,  0.1769],
        [-0.0484, -0.0052],
        [ 0.1287, -0.2580],
        [ 0.1102,  0.1327],
        [ 0.0945, -0.2166]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.1524, -0.0845],
        [-0.0033, -0.1727],
        [ 0.0781, -0.0292],
        [-0.4559,  0.2137],
        [-0.4092,  0.3127],
        [-0.3566,  0.3781],
        [ 0.3396, -0.4012],
        [-0.2549,  0.0275],
        [-0.1605,  0.1719],
        [ 0.0858, -0.1837],
        [-0.0363,  0.0389],
        [-0.2733,  0.2598]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[ 0.4423, -0.3648],
        [ 0.1434, -0.0589],
        [ 0.0606, -0.0893],
        [ 0.1885, -0.4074],
        [-0.0521,  0.0695],
        [ 0.0423,  0.1271],
        [-0.4332,  0.2988],
        [ 0.0092,  0.2143],
        [-0.1729,  0.0057],
        [ 0.3311, -0.1955],
        [-0.0450, -0.0870],
        [-0.0198,  0.1075]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 0.2444, -0.0037],
        [ 0.0258, -0.0501],
        [-0.1811,  0.4110],
        [ 0.0248,  0.0214],
        [ 0.0777,  0.1438],
        [ 0.4770, -0.1524],
        [-0.1540,  0.1143],
        [ 0.1799, -0.2315],
        [ 0.3047, -0.1804],
        [-0.0777,  0.0571],
        [ 0.0149, -0.1223],
        [-0.1989,  0.0558]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 0.1145, -0.1529],
        [ 0.1967, -0.0254],
        [-0.3515,  0.3325],
        [ 0.1983, -0.2859],
        [ 0.1725, -0.1707],
        [ 0.2034, -0.1138],
        [-0.2534,  0.2594],
        [-0.1373, -0.0052],
        [-0.1516,  0.1134],
        [-0.1136,  0.0404],
        [-0.3200, -0.0225],
        [-0.1369,  0.1814]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[ 0.0171,  0.0139],
        [ 0.2473, -0.2178],
        [ 0.0032, -0.1019],
        [ 0.2272, -0.2177],
        [ 0.2358, -0.2504],
        [-0.0925,  0.1372],
        [-0.0791,  0.1448],
        [ 0.0258, -0.0698],
        [ 0.2167, -0.0951],
        [-0.2866,  0.3721],
        [-0.2806,  0.1004],
        [ 0.0563, -0.0824]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[ 0.3201, -0.3193],
        [-0.0227,  0.1435],
        [-0.2417,  0.2451],
        [-0.1679,  0.1762],
        [-0.2327,  0.2007],
        [-0.0631,  0.0530],
        [-0.1201,  0.1697],
        [-0.2784,  0.2542],
        [ 0.2178, -0.1516],
        [-0.0840,  0.1501],
        [-0.1169, -0.0329],
        [-0.1152,  0.2337]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[ 1.1485e-01, -1.4145e-01],
        [-9.3542e-01,  7.0010e-01],
        [-7.2289e-02,  1.3829e-01],
        [ 2.9382e-03, -1.4252e-01],
        [ 1.5599e-01, -3.3887e-01],
        [-2.2035e-02, -8.2651e-02],
        [-1.7488e-01,  2.4037e-01],
        [ 1.4207e-01, -1.2576e-01],
        [ 2.8017e-04,  3.4038e-02],
        [ 6.1924e-02, -7.3823e-02],
        [-2.5864e-01,  2.1301e-01],
        [-3.1444e-01,  2.6442e-01]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[ 0.2069, -0.0198],
        [ 0.0496,  0.1111],
        [ 0.0424, -0.0184],
        [-0.1012,  0.1157],
        [-0.2342,  0.2573],
        [ 0.0861, -0.1245],
        [-0.0636, -0.0916],
        [-0.2109,  0.5565],
        [-0.0917,  0.0548],
        [-0.1947,  0.0672],
        [ 0.0959, -0.2626],
        [ 0.3020, -0.0316]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[ 0.1877, -0.0850],
        [ 0.3951, -0.3117],
        [-0.0765,  0.0980],
        [-0.0636,  0.0568],
        [ 0.2367, -0.2063],
        [ 0.0496, -0.1109],
        [ 0.0563, -0.0732],
        [ 0.0862, -0.0662],
        [-0.2827,  0.0278],
        [ 0.5202, -0.4446],
        [-0.0009,  0.2426],
        [-0.3897,  0.2251]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-0.2833,  0.1464],
        [ 0.1020, -0.2347],
        [-0.2619,  0.2035],
        [ 0.3355, -0.2610],
        [ 0.3465, -0.3160],
        [ 0.2702, -0.2159],
        [ 0.0834, -0.3170],
        [-0.1900,  0.2152],
        [ 0.1993,  0.0960],
        [ 0.1591, -0.0196],
        [-0.2573,  0.0659],
        [-0.1219, -0.1254]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[ 0.2266,  0.0452],
        [ 0.1554, -0.1473],
        [ 0.4197, -0.4512],
        [-0.2107,  0.1336],
        [-0.1659,  0.0708],
        [-0.0084, -0.0232],
        [-0.3956,  0.1654],
        [ 0.6866, -0.4018],
        [ 0.5357, -0.3978],
        [-0.0708,  0.2204],
        [-0.0105, -0.0964],
        [-0.1495,  0.0621]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[ 0.2208, -0.3297],
        [ 0.4481, -0.5820],
        [-0.0618,  0.2656],
        [-0.0093, -0.1261],
        [-0.3914,  0.3682],
        [ 0.2467, -0.1162],
        [ 1.0065, -0.7035],
        [ 0.3373, -0.1422],
        [ 0.0286,  0.1798],
        [-0.0084, -0.1908],
        [ 0.2123, -0.1969],
        [-0.0141,  0.0162]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[ 0.1773,  0.0202],
        [ 0.2024, -0.3339],
        [ 0.1430,  0.0468],
        [ 0.2868, -0.1830],
        [ 0.1189, -0.0536],
        [-0.0452,  0.2290],
        [-0.3023,  0.2886],
        [-0.3465,  0.3263],
        [-0.1376,  0.3174],
        [-0.4138,  0.4311],
        [-0.1619,  0.1182],
        [ 0.1355,  0.2186]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[-0.0813, -0.0288],
        [-0.3100,  0.1504],
        [-0.4136,  0.4713],
        [-0.0967,  0.2114],
        [-0.0895,  0.2582],
        [ 0.3619, -0.2522],
        [-0.1931,  0.2348],
        [-0.0876,  0.2031],
        [ 0.2081,  0.0794],
        [ 0.1210,  0.0116],
        [-0.1485,  0.1710],
        [-0.5063,  0.4851]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 0.4434, -0.3300],
        [ 0.1143, -0.1725],
        [-0.3763,  0.3749],
        [ 0.3160, -0.1168],
        [-0.0519,  0.1718],
        [-0.0191,  0.0498],
        [-0.5665,  0.3593],
        [ 0.1334, -0.2301],
        [-0.0102, -0.0136],
        [ 0.5885, -0.2571],
        [-0.1635,  0.0273],
        [-0.3373,  0.2579]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[ 0.1721,  0.0587],
        [-0.0548,  0.0570],
        [ 0.1643, -0.2350],
        [ 0.3183, -0.1745],
        [ 0.1133,  0.1328],
        [-0.2808,  0.2675],
        [-0.1396,  0.1702],
        [ 0.5675, -0.4072],
        [-0.1621,  0.1780],
        [-0.2535,  0.4051],
        [-0.1578,  0.2643],
        [ 0.0668,  0.0018]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-0.3607,  0.4232],
        [ 0.0806,  0.3882],
        [-0.0363,  0.1620],
        [ 0.2467, -0.1191],
        [-0.4370,  0.3874],
        [-0.3794,  0.3517],
        [-0.4277,  0.4262],
        [-0.0545,  0.1966],
        [ 0.3577, -0.2339],
        [ 0.2736,  0.1591],
        [-0.0606,  0.0028],
        [-0.1498,  0.2655]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-0.1423,  0.0016],
        [-0.4529,  0.2581],
        [ 0.4888, -0.0985],
        [-0.2965,  0.2453],
        [-0.2335,  0.1695],
        [ 0.3091,  0.0127],
        [ 0.1726,  0.2578],
        [-0.4056,  0.1478],
        [ 0.0924,  0.0102],
        [ 0.0450, -0.0899],
        [ 0.2879, -0.0423],
        [ 0.1227, -0.0172]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[ 0.0308, -0.0501],
        [ 0.1494, -0.2279],
        [ 0.0291,  0.1132],
        [ 0.1056,  0.0546],
        [-0.1331,  0.3854],
        [ 0.0518, -0.0534],
        [ 0.7072, -0.5933],
        [ 0.0078,  0.0752],
        [ 0.2207, -0.0367],
        [ 0.0094,  0.1059],
        [ 0.0176, -0.0862],
        [-0.0467,  0.1019]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[ 0.2577,  0.0394],
        [ 0.1808,  0.3045],
        [ 0.1816,  0.0028],
        [-0.3069,  0.1178],
        [ 0.0808,  0.0406],
        [-0.1218,  0.2512],
        [-0.3022,  0.1145],
        [ 0.3108,  0.1951],
        [-0.3492,  0.3143],
        [ 0.0721,  0.1989],
        [ 0.1615,  0.2377],
        [-0.0733,  0.3110]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-0.2678,  0.2620],
        [ 0.3716, -0.1285],
        [-0.2557,  0.2346],
        [ 0.3110, -0.3949],
        [ 0.5980, -0.2774],
        [-0.4064,  0.5323],
        [ 0.1543, -0.0182],
        [ 0.5064, -0.1815],
        [-0.1127,  0.2220],
        [ 0.0284,  0.2159],
        [ 0.0243,  0.2495],
        [-0.0406,  0.0429]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-0.0930, -0.1104],
        [-0.3822,  0.5801],
        [ 0.6067, -0.5552],
        [ 0.2053,  0.0304],
        [-0.1022,  0.2258],
        [ 0.0413,  0.1428],
        [-0.0381,  0.2657],
        [ 0.2124,  0.0717],
        [ 0.3716, -0.2025],
        [ 0.8374, -0.4855],
        [-0.1244,  0.3272],
        [-0.0103,  0.1788]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[ 3.9815e-01, -4.3954e-01],
        [ 1.6580e-01,  5.5068e-02],
        [ 1.4839e-01,  4.4921e-02],
        [-1.0948e-01, -4.6674e-02],
        [-6.7677e-01,  6.1026e-01],
        [-1.3274e-01,  1.6330e-01],
        [ 6.1312e-01, -5.7977e-01],
        [ 1.1886e-01,  1.1687e-02],
        [ 1.8944e-01, -9.9698e-02],
        [-1.6115e-01,  6.4536e-04],
        [-3.0984e-02,  4.2546e-02],
        [-3.2374e-03, -5.2129e-02]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[ 0.4581, -0.1201],
        [ 0.1084,  0.0477],
        [ 0.1689, -0.0488],
        [-0.0808,  0.2128],
        [ 0.3207, -0.1143],
        [ 0.4339, -0.0709],
        [-0.3828,  0.4470],
        [ 0.3170, -0.1670],
        [-0.4329,  0.2858],
        [ 0.2807, -0.0448],
        [ 0.4917, -0.2898],
        [ 0.1034, -0.0791]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 0.1811,  0.2937],
        [-0.0099,  0.0540],
        [ 0.0296,  0.0064],
        [-0.3249,  0.5609],
        [ 0.1546, -0.1317],
        [ 0.4595, -0.1424],
        [ 0.3335, -0.2225],
        [ 0.0995,  0.0992],
        [ 0.0632,  0.0990],
        [ 0.0914,  0.2442],
        [ 0.0470, -0.0215],
        [-0.4580,  0.5073]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[-0.0163, -0.1226],
        [ 0.5665, -0.4414],
        [-0.6010,  0.5032],
        [ 0.2808, -0.1973],
        [ 0.0670, -0.0744],
        [ 0.1484, -0.0499],
        [ 0.2642,  0.0320],
        [ 0.3276, -0.3488],
        [ 0.1593, -0.1965],
        [-0.0470, -0.0610],
        [ 0.3302,  0.0088],
        [ 0.0023,  0.1671]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[ 0.0782, -0.0202],
        [ 0.3178,  0.0380],
        [ 0.1942, -0.0678],
        [ 0.1200, -0.0553],
        [-0.2054,  0.0628],
        [-0.5039,  0.5202],
        [-0.2571,  0.3290],
        [-0.0322,  0.0917],
        [-0.0779,  0.2900],
        [-0.1486,  0.2961],
        [-0.2604,  0.2762],
        [-0.3067,  0.1016]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-0.0879,  0.1573],
        [ 0.1589, -0.2807],
        [-0.2881,  0.4421],
        [-0.1120,  0.1756],
        [-0.0534,  0.0773],
        [-0.0177, -0.0483],
        [-0.1753,  0.2199],
        [-0.0982,  0.2712],
        [ 0.2725, -0.2578],
        [ 0.2119,  0.1234],
        [ 0.2004,  0.1758],
        [ 0.6670, -0.3270]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-0.2828,  0.3767],
        [-0.0938,  0.2103],
        [ 0.0870,  0.1014],
        [ 0.2768, -0.1486],
        [ 0.4194, -0.1740],
        [-0.0922,  0.2097],
        [-0.0336,  0.0072],
        [ 0.1715, -0.1164],
        [ 0.0999,  0.2387],
        [ 0.2409, -0.2094],
        [ 0.4791, -0.2138],
        [ 0.1321, -0.1996]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-0.2472,  0.1582],
        [ 0.5761, -0.2670],
        [-0.0518,  0.1746],
        [ 0.0731, -0.0095],
        [ 0.1950,  0.0471],
        [ 0.3100, -0.2826],
        [-0.2607,  0.0545],
        [-0.2805,  0.2359],
        [ 0.3614, -0.3744],
        [ 0.0563, -0.0751],
        [ 0.6826, -0.2591],
        [ 0.0874,  0.0212]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[ 0.2968, -0.1705],
        [-0.0805,  0.0870],
        [ 0.1441,  0.2555],
        [-0.1902,  0.0416],
        [ 0.0796, -0.1648],
        [-0.4248,  0.1371],
        [ 0.1502, -0.0876],
        [-0.1432,  0.3958],
        [-0.3035,  0.2472],
        [ 0.3442, -0.1970],
        [ 0.0656,  0.2813],
        [-0.1610,  0.3385]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-0.1075,  0.1120],
        [-0.4093,  0.3311],
        [ 0.1101,  0.1181],
        [-0.1155,  0.3266],
        [ 0.4110, -0.2935],
        [ 0.0245,  0.2422],
        [ 0.0691,  0.1417],
        [-0.1764,  0.4046],
        [-0.2989,  0.2045],
        [ 0.2475, -0.0283],
        [ 0.0532,  0.2683],
        [-0.1401,  0.1535]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-0.1896,  0.2423],
        [-0.4665,  0.6128],
        [ 0.5067, -0.5471],
        [ 0.0700,  0.3006],
        [ 0.0436,  0.1432],
        [-0.3652,  0.3609],
        [-0.0241,  0.2865],
        [-0.1947,  0.3528],
        [-0.2512,  0.2778],
        [ 0.1082,  0.1830],
        [ 0.0531,  0.0699],
        [-0.7535,  0.7274]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.0430,  0.1773],
        [ 0.6681, -0.5629],
        [ 0.0425,  0.1258],
        [-0.0212,  0.3264],
        [-0.6001,  0.8539],
        [-0.0242,  0.2077],
        [ 0.3292, -0.3654],
        [ 0.0906, -0.1755],
        [ 0.2937, -0.1043],
        [-0.0832,  0.1435],
        [-0.1609,  0.1731],
        [-0.0254,  0.0049]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[ 0.4217, -0.2159],
        [ 0.4115,  0.0434],
        [ 0.5069, -0.2457],
        [ 0.0441, -0.0855],
        [ 0.1316, -0.1054],
        [ 0.0314,  0.0368],
        [-0.0722,  0.2964],
        [ 0.5649, -0.2063],
        [ 0.3433,  0.0820],
        [ 0.1578,  0.0549],
        [ 0.2229,  0.0581],
        [ 0.3001, -0.2376]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[-0.0450,  0.2834],
        [ 0.0321, -0.0997],
        [-0.4097,  0.3945],
        [-0.6022,  0.5590],
        [-0.1302,  0.1602],
        [ 0.8912, -0.3841],
        [ 0.1446,  0.0651],
        [-0.1035,  0.4417],
        [ 0.1305, -0.2562],
        [-0.2232,  0.1769],
        [ 0.1905,  0.1882],
        [-0.4395,  0.5565]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 0.2440, -0.1041],
        [ 0.4299, -0.1716],
        [ 0.0152,  0.2465],
        [ 0.3685, -0.3004],
        [-0.0170,  0.3100],
        [ 0.4225, -0.0006],
        [ 0.2140, -0.0276],
        [ 0.1564, -0.1181],
        [-0.4019,  0.3515],
        [ 0.4385, -0.1568],
        [ 0.1238,  0.0952],
        [-0.3964,  0.5899]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[-0.0597,  0.3781],
        [ 0.2292, -0.0702],
        [-0.0193,  0.0592],
        [ 0.6497, -0.5348],
        [ 0.0956, -0.0725],
        [-0.0327,  0.2012],
        [-0.7183,  0.6462],
        [ 0.5901, -0.4119],
        [-0.0276,  0.1936],
        [-0.3325,  0.4742],
        [-0.1728,  0.5877],
        [ 0.4368, -0.1981]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[ 0.1792,  0.1347],
        [ 0.2580, -0.0951],
        [ 0.0966,  0.0040],
        [ 0.0869,  0.0867],
        [ 0.2815,  0.1593],
        [ 0.3543, -0.1133],
        [-0.2605,  0.2654],
        [-0.3216,  0.3944],
        [ 0.7353, -0.4713],
        [ 0.4091, -0.0387],
        [ 0.0852,  0.0931],
        [ 0.3064, -0.1018]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-0.1117,  0.3401],
        [ 0.2154,  0.1739],
        [-0.0745,  0.3847],
        [ 0.5872, -0.3946],
        [ 0.2216, -0.2633],
        [ 0.0544,  0.3089],
        [-0.2878,  0.2266],
        [ 0.1495,  0.0901],
        [-0.1263,  0.3708],
        [-0.1392,  0.2338],
        [ 0.4928, -0.4721],
        [ 0.3512, -0.1616]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[ 0.1004, -0.0617],
        [ 0.0164,  0.3382],
        [ 0.0204,  0.0549],
        [-0.2882,  0.4035],
        [-0.2137,  0.1528],
        [-0.0766,  0.0812],
        [ 0.3367, -0.2405],
        [-0.1120,  0.2170],
        [ 0.3982, -0.1461],
        [-0.0203,  0.2505],
        [-0.3712,  0.2173],
        [-0.3524,  0.3636]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[ 0.0985, -0.1596],
        [ 0.4912, -0.1586],
        [-0.0949,  0.3477],
        [-0.0067,  0.2930],
        [-0.0173,  0.0521],
        [-0.1313,  0.3097],
        [-0.3309,  0.4850],
        [-0.0404,  0.0998],
        [-0.3104,  0.3680],
        [-0.0729,  0.0348],
        [ 0.3187, -0.0239],
        [-0.3318,  0.3011]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-0.4744,  0.3362],
        [-0.0675, -0.0251],
        [-0.0738,  0.1412],
        [ 0.0968, -0.0206],
        [ 0.6824, -0.2962],
        [-0.3861,  0.5320],
        [-0.0568,  0.0910],
        [ 0.3161, -0.1653],
        [ 0.1153,  0.0604],
        [ 0.2127, -0.2675],
        [-0.4789,  0.5827],
        [-0.1458,  0.4094]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-0.0046,  0.3172],
        [ 0.0998,  0.1402],
        [ 0.3115, -0.1720],
        [-0.1769,  0.2471],
        [-0.0938,  0.3406],
        [ 0.1664, -0.0908],
        [-0.1435,  0.2284],
        [-0.2880,  0.5534],
        [-0.2093,  0.2031],
        [ 0.2961, -0.0496],
        [-0.0159,  0.2493],
        [-0.5868,  0.6180]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.2459,  0.2537],
        [ 0.3277, -0.2281],
        [-0.0249,  0.2815],
        [-0.2282,  0.2959],
        [ 0.2712,  0.0264],
        [-0.0997,  0.2115],
        [ 0.3947, -0.3158],
        [ 0.0845,  0.1848],
        [ 0.0556, -0.0919],
        [ 0.9834, -0.7524],
        [-0.0175, -0.0541],
        [ 0.2499, -0.0113]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[ 0.2647, -0.2088],
        [-0.0206,  0.1610],
        [ 0.4859, -0.2539],
        [ 0.2781,  0.1179],
        [-0.2020,  0.0863],
        [ 0.4537, -0.2246],
        [-0.1912,  0.2559],
        [ 0.0358, -0.0097],
        [-0.2652,  0.1944],
        [ 0.1608,  0.0645],
        [ 0.5630, -0.4764],
        [ 0.0680,  0.0493]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 0.9619, -0.4989],
        [-0.0532,  0.0902],
        [-0.1811,  0.2819],
        [-0.6749,  0.7157],
        [ 0.6332, -0.5521],
        [ 0.6030, -0.4803],
        [-0.0093,  0.3637],
        [-0.1381,  0.2272],
        [ 0.2894, -0.1140],
        [ 0.0560, -0.1263],
        [ 0.1590, -0.0058],
        [-0.0300,  0.1086]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 0.7562, -0.5155],
        [-0.1023,  0.0939],
        [-0.6279,  0.7601],
        [ 0.0143,  0.2322],
        [ 0.2482, -0.0791],
        [ 0.5343, -0.0548],
        [ 0.2349, -0.2102],
        [ 0.0616, -0.2659],
        [ 0.2337, -0.1947],
        [-0.0298,  0.1778],
        [ 0.0029,  0.0365],
        [-0.4956,  0.5551]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[ 0.6342, -0.3972],
        [ 0.1277,  0.0314],
        [ 0.0534, -0.0846],
        [ 0.4347, -0.5158],
        [ 0.2925,  0.0122],
        [-0.1467,  0.1034],
        [-0.2773,  0.1181],
        [ 0.3294, -0.1830],
        [-0.1061,  0.2981],
        [-0.1467,  0.2691],
        [-0.3198,  0.2426],
        [ 0.0130,  0.1707]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[ 0.1732, -0.1226],
        [ 0.2063,  0.0752],
        [-0.4192,  0.4486],
        [ 0.0200, -0.0479],
        [ 0.0364,  0.1082],
        [ 0.3325, -0.2073],
        [ 0.0116, -0.0530],
        [-0.0045,  0.1943],
        [ 0.5008, -0.5375],
        [ 0.0436,  0.2770],
        [ 0.4469, -0.5232],
        [ 0.3124, -0.1934]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-0.4154,  0.5175],
        [-0.2383,  0.1579],
        [ 0.3067,  0.0159],
        [ 0.2696, -0.2002],
        [ 0.0481,  0.2590],
        [ 0.1398, -0.0361],
        [ 0.2485,  0.0535],
        [-0.0690, -0.0021],
        [-0.4437,  0.4391],
        [ 0.0473, -0.0698],
        [ 0.0521, -0.0149],
        [ 0.4892, -0.1920]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-5.7105e-01,  7.6490e-01],
        [ 2.5256e-01, -1.3109e-02],
        [ 3.0001e-04, -2.7793e-02],
        [-6.7472e-01,  5.7396e-01],
        [ 2.9832e-01, -2.3201e-01],
        [-3.4605e-02,  1.3908e-01],
        [ 4.1027e-01, -3.7016e-01],
        [ 2.0267e-01, -1.9176e-01],
        [ 4.9222e-01, -4.3934e-01],
        [ 4.6721e-02, -2.4472e-02],
        [-1.5663e-01,  3.1892e-01],
        [ 1.2615e-01, -4.9194e-02]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[ 0.1325, -0.1461],
        [ 0.7073, -0.3433],
        [-0.0095,  0.2042],
        [-0.7388,  0.8830],
        [ 0.3245, -0.1170],
        [-0.1660,  0.1533],
        [-0.1160,  0.4216],
        [-0.2307,  0.2495],
        [-0.1688,  0.1484],
        [ 0.3309, -0.0507],
        [-0.0644,  0.4012],
        [-0.1687,  0.2547]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-0.2972,  0.3304],
        [-0.0146,  0.1688],
        [ 0.1656, -0.0710],
        [ 0.3538, -0.0546],
        [ 0.4431, -0.3160],
        [ 0.1322,  0.0174],
        [ 0.1990, -0.0862],
        [-0.1442,  0.0408],
        [-0.2322,  0.4076],
        [ 0.1134, -0.1338],
        [-0.2055,  0.1261],
        [ 0.0121,  0.0181]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-0.5978,  0.5662],
        [-0.2448,  0.4067],
        [ 0.0910, -0.0013],
        [-0.2386,  0.1649],
        [ 0.3609,  0.0394],
        [-0.3166,  0.2142],
        [ 0.0464, -0.0470],
        [-0.2265,  0.3726],
        [ 0.5548, -0.3192],
        [ 0.0450,  0.1907],
        [-0.1246,  0.2178],
        [-0.7408,  0.7356]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[ 0.1595, -0.1900],
        [ 0.4665, -0.2902],
        [ 0.0421,  0.2481],
        [-0.4641,  0.6038],
        [-0.3101,  0.4134],
        [ 0.1327,  0.0393],
        [ 0.0514,  0.1689],
        [-0.0369, -0.0356],
        [-0.0050, -0.1734],
        [ 0.4318, -0.4510],
        [-0.1589, -0.0136],
        [ 0.3321, -0.2151]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-0.4113,  0.3516],
        [ 0.3558, -0.0874],
        [ 0.3309, -0.0380],
        [-0.0617,  0.0789],
        [ 0.1161, -0.1500],
        [ 0.0109,  0.3137],
        [-0.2989,  0.2053],
        [ 0.0965, -0.0125],
        [-0.1587,  0.1374],
        [ 0.4602, -0.3874],
        [ 0.0788, -0.1432],
        [-0.3214,  0.3831]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 0.3216, -0.2594],
        [ 0.1962, -0.2062],
        [-0.1910,  0.4645],
        [-0.5599,  0.7188],
        [ 0.1148,  0.1535],
        [ 0.6360, -0.4166],
        [-0.2519,  0.4175],
        [-0.0860,  0.1420],
        [ 0.1801, -0.0109],
        [-0.2935,  0.6036],
        [ 0.3228, -0.2286],
        [-0.2182,  0.2090]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 0.1327, -0.0370],
        [-0.2537,  0.1238],
        [-0.3337,  0.1349],
        [ 0.2224, -0.0803],
        [-0.6128,  0.5589],
        [ 0.0287, -0.0631],
        [-0.1911,  0.1224],
        [ 0.0915, -0.0778],
        [-0.1517,  0.1391],
        [ 0.1293, -0.1229],
        [-0.1808,  0.2910],
        [-0.1263,  0.2269]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[ 0.0045,  0.1305],
        [ 0.1043,  0.0688],
        [-0.1060,  0.0478],
        [ 0.5925, -0.4481],
        [-0.1771,  0.4480],
        [-0.0780,  0.1153],
        [-0.7668,  0.3507],
        [ 0.1808, -0.3251],
        [ 0.4376, -0.4012],
        [-0.2928,  0.3069],
        [-0.1199,  0.0450],
        [-0.0920, -0.0109]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-0.1000,  0.1864],
        [-0.0449, -0.0309],
        [-0.0593,  0.0472],
        [ 0.0561, -0.2294],
        [-0.1802,  0.3521],
        [-0.6009,  0.4456],
        [-0.1829,  0.0417],
        [-0.3916,  0.3215],
        [ 0.9763, -0.6873],
        [-0.4834,  0.5752],
        [-0.1307,  0.1259],
        [ 0.9097, -0.5842]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-0.3395,  0.4187],
        [-0.4627,  0.4960],
        [ 0.2725, -0.2117],
        [ 0.0165,  0.1936],
        [ 0.0399, -0.0152],
        [-0.6588,  0.5528],
        [-0.2130,  0.4968],
        [-0.0928,  0.2191],
        [-0.1428,  0.3030],
        [-0.6683,  0.4572],
        [ 0.1952, -0.4378],
        [ 0.1581,  0.0608]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-0.6294,  0.5443],
        [-1.1348,  0.9082],
        [-0.1585,  0.2210],
        [-1.3099,  0.9519],
        [-1.1634,  0.7243],
        [-1.0490,  0.5088],
        [ 0.3957, -0.3801],
        [-1.0383,  1.1418],
        [-1.0974,  0.7354],
        [-1.0635,  0.7102],
        [-0.8011,  1.0040],
        [-0.9113,  0.7310]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-0.2973,  0.1576],
        [-0.0896,  0.0186],
        [-1.0347,  0.7899],
        [-0.1151,  0.0815],
        [-0.2816,  0.3463],
        [-0.0821,  0.3544],
        [-0.7489,  0.3626],
        [-0.8626,  0.7080],
        [ 0.2844,  0.4532],
        [-0.5564,  0.3682],
        [-1.1441,  1.1619],
        [-0.8153,  0.6500]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-0.3416,  0.3944],
        [ 0.5651, -0.2329],
        [-0.1622,  0.1022],
        [-0.2909,  0.0761],
        [ 0.4300, -0.0453],
        [-0.2541,  0.2591],
        [-0.1713,  0.1621],
        [ 1.4055, -1.2396],
        [-0.1651,  0.2781],
        [ 0.1863, -0.3176],
        [-0.1658,  0.2982],
        [ 0.2887,  0.0704]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-0.4633,  0.2664],
        [-0.3497,  0.1271],
        [ 1.3762, -1.2114],
        [ 0.9390, -0.8006],
        [-1.0027,  0.6768],
        [-0.3963,  0.2266],
        [-0.1354,  0.5281],
        [-0.7299,  0.7086],
        [-0.6934,  0.3258],
        [ 0.1647, -0.4835],
        [ 0.7833, -0.5847],
        [ 0.2835, -0.2005]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.3064,  0.3077],
        [-0.4103,  0.1414],
        [-0.0721,  0.2335],
        [-0.2740, -0.0177],
        [ 1.1105, -1.0713],
        [-0.3572,  0.2393],
        [ 1.2437, -1.0671],
        [-0.2504,  0.0511],
        [-0.5442,  0.4952],
        [-0.0412,  0.1144],
        [-0.2599,  0.3241],
        [-0.2128,  0.4256]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-0.5837,  0.7400],
        [ 0.6440, -0.5629],
        [ 0.6384, -0.6582],
        [-0.0393,  0.2660],
        [ 0.3658, -0.3842],
        [-0.2419,  0.1042],
        [-0.4603,  0.4712],
        [ 0.9609, -0.6124],
        [-0.2968,  0.2126],
        [ 0.4150, -0.2529],
        [-0.8640,  0.5900],
        [-0.7197,  0.5611]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 0.9341, -0.9870],
        [ 0.2615,  0.0325],
        [-0.7261,  0.6755],
        [-0.2906,  0.0172],
        [-0.2551,  0.1457],
        [-0.3251,  0.2330],
        [ 0.2376,  0.0918],
        [-0.5990,  0.5619],
        [-0.0564, -0.1038],
        [-0.6868,  0.5289],
        [-0.1757,  0.0988],
        [-0.2287,  0.2292]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[-0.2291,  0.5115],
        [-0.3880,  0.3584],
        [-0.2579,  0.1456],
        [ 0.0086,  0.2173],
        [-0.2951,  0.3076],
        [ 0.4599, -0.3438],
        [-0.1368,  0.1309],
        [-1.0203,  0.7298],
        [-0.5230,  0.7110],
        [-0.4107, -0.0928],
        [-0.5956,  0.4569],
        [-0.5563,  0.2841]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[-0.6945,  0.5607],
        [-0.4755,  0.5479],
        [-0.5309,  0.4660],
        [ 0.1978, -0.2767],
        [ 0.6555, -0.2348],
        [-1.0784,  0.8413],
        [-0.3868,  0.6884],
        [-0.0934,  0.3435],
        [-0.8990,  0.7234],
        [-0.5765,  0.4562],
        [-0.4155,  0.1510],
        [ 0.5576, -0.2808]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-0.7345,  0.3294],
        [ 0.3993, -0.4617],
        [-0.3080,  0.5234],
        [-0.4400,  0.8127],
        [-0.9358,  0.8935],
        [-0.8258,  0.5243],
        [-0.8889,  0.6292],
        [-1.2138,  0.9800],
        [ 0.7654, -0.6252],
        [-0.9267,  0.4365],
        [ 0.8881, -0.8559],
        [-0.9342,  0.9034]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-0.7895,  0.7892],
        [-1.3554,  1.0561],
        [-0.5474,  0.4565],
        [ 0.1210,  0.0287],
        [ 0.6022, -0.4916],
        [-1.1077,  1.2592],
        [-0.7480,  0.7511],
        [-0.0594,  0.2694],
        [-0.6281,  0.5163],
        [ 0.3794, -0.1585],
        [-0.7731,  0.3823],
        [ 0.8716, -0.5945]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-0.9003,  0.7396],
        [-0.6733,  0.5672],
        [-0.0219,  0.0297],
        [-0.0935,  0.2141],
        [-0.4500,  0.3934],
        [-0.5900,  0.6149],
        [-1.0654,  0.7643],
        [-0.8229,  1.0193],
        [ 0.5553, -0.6864],
        [-0.9038,  0.7407],
        [-0.3979,  0.3607],
        [-1.0043,  1.1239]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-0.1784,  0.5075],
        [ 0.3683, -0.1093],
        [-1.3015,  0.8708],
        [-0.4231,  0.7459],
        [-0.8906,  0.5217],
        [-0.1781,  0.5120],
        [-0.6503,  0.5230],
        [-1.1180,  1.1182],
        [-0.5333,  0.2894],
        [-0.8639,  0.4291],
        [-1.4176,  1.1622],
        [ 0.2519,  0.0634]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-1.1991,  1.2123],
        [ 0.9861, -0.6379],
        [-0.9898,  0.7625],
        [-0.3918,  0.3606],
        [ 0.3824,  0.0674],
        [-0.7612,  0.6025],
        [-0.2389,  0.0345],
        [ 0.4253, -0.3347],
        [-0.6291,  0.4732],
        [-1.4114,  1.0963],
        [-0.2191,  0.3805],
        [-0.3197,  0.1384]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-0.0957,  0.2730],
        [-0.5439,  0.5049],
        [ 0.9397, -0.5835],
        [ 0.0115,  0.1734],
        [-0.5794,  0.5031],
        [-0.6221,  0.5912],
        [-1.1002,  0.8715],
        [-1.3337,  0.9626],
        [-1.5249,  1.4857],
        [-0.5810,  0.3402],
        [-1.2845,  1.0710],
        [-0.0615, -0.0517]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.6448,  0.1972],
        [ 0.4954, -0.6403],
        [-0.6671,  0.4967],
        [-0.1674,  0.3370],
        [ 0.4769, -0.4925],
        [-1.0904,  1.0794],
        [-1.2735,  0.6690],
        [-0.1158,  0.0615],
        [-0.5515,  0.6577],
        [-0.1228,  0.4767],
        [-0.1055,  0.0865],
        [-0.1006,  0.1924]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[ 0.1559,  0.1253],
        [-0.0351,  0.1724],
        [ 0.0137,  0.2104],
        [ 0.4474, -0.1399],
        [ 0.5467, -0.2854],
        [ 0.4508, -0.2598],
        [ 0.4115, -0.2923],
        [ 0.0425,  0.3314],
        [-0.6271,  0.4329],
        [ 0.5010, -0.0942],
        [ 0.1862, -0.0861],
        [-0.2692,  0.5925]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[-0.2874,  0.6329],
        [ 0.0305,  0.2897],
        [-0.2358,  0.5361],
        [-0.5575,  0.7527],
        [ 0.3492, -0.1155],
        [ 0.1183,  0.3363],
        [-0.6938,  0.8757],
        [-0.6925,  0.9583],
        [-0.0910,  0.5583],
        [ 0.0588,  0.3133],
        [-0.6331,  1.0123],
        [-0.5442,  0.8268]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 0.0515,  0.4154],
        [ 0.7519, -0.3181],
        [ 0.5377, -0.1221],
        [ 0.1228,  0.2253],
        [ 0.0174,  0.1430],
        [ 0.0391,  0.2543],
        [ 0.7825, -0.1510],
        [ 0.1301, -0.0083],
        [-0.2308,  0.3834],
        [-0.6931,  0.8954],
        [-0.1458,  0.5181],
        [-0.3093,  0.5969]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[ 0.4243,  0.1535],
        [ 0.1191,  0.2461],
        [ 0.1449,  0.0732],
        [ 0.5068,  0.0250],
        [ 0.5861, -0.1274],
        [-0.3462,  0.6397],
        [-0.1803,  0.3755],
        [ 0.5482, -0.0865],
        [ 0.2118,  0.1039],
        [ 0.1070,  0.2043],
        [ 0.0193,  0.2110],
        [ 0.5423, -0.1582]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[ 0.0726,  0.2774],
        [ 0.4682,  0.0378],
        [ 0.5293, -0.2652],
        [ 0.6637,  0.1469],
        [ 0.1175,  0.4021],
        [ 0.1462,  0.3012],
        [ 0.2979, -0.0914],
        [-0.2699,  0.8564],
        [ 1.1054, -0.6524],
        [-0.2534,  0.3975],
        [ 1.3197, -0.5905],
        [ 1.0704, -0.7631]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-0.6364,  0.8948],
        [-0.4319,  0.6774],
        [ 0.3430,  0.2817],
        [-0.3174,  0.5617],
        [-0.0477,  0.2647],
        [-0.5299,  0.7900],
        [-0.8783,  0.9805],
        [-0.5402,  0.7409],
        [ 0.1841,  0.0694],
        [ 0.2946, -0.0500],
        [ 0.2307,  0.0421],
        [-0.1025,  0.4728]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-0.0022,  0.3858],
        [-0.1339,  0.3925],
        [-0.5723,  0.8605],
        [-0.4890,  0.7424],
        [-0.4117,  0.8470],
        [ 0.1836,  0.0656],
        [-0.0916,  0.3642],
        [-0.2476,  0.4314],
        [ 0.0816,  0.4133],
        [-0.4919,  0.7042],
        [ 0.1204,  0.0922],
        [-0.4876,  0.6705]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[ 0.4216,  0.1965],
        [ 0.6571, -0.2907],
        [-0.4126,  0.5398],
        [ 0.4047, -0.0780],
        [ 0.1351,  0.0469],
        [ 0.9112, -0.5615],
        [-0.4917,  0.7724],
        [ 0.0274,  0.3856],
        [-0.3012,  0.6842],
        [-0.6371,  1.0040],
        [ 0.1998,  0.1852],
        [-0.4424,  0.9109]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-0.6905,  0.7951],
        [ 0.6696, -0.3220],
        [-0.9339,  1.0351],
        [-0.1629,  0.4383],
        [-0.1800,  0.4549],
        [ 0.1535,  0.0706],
        [-0.0773,  0.2940],
        [ 0.0042,  0.6109],
        [-0.3017,  0.5248],
        [-0.3032,  0.7017],
        [ 0.1143, -0.1699],
        [-0.1390,  0.5159]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-0.1206,  0.5947],
        [ 0.4758,  0.1627],
        [ 0.9792, -0.6383],
        [ 0.2306,  0.1723],
        [-0.6293,  0.7716],
        [ 0.0934,  0.2356],
        [-0.3375,  0.7750],
        [-0.4972,  0.8830],
        [-0.2409,  0.4639],
        [ 0.2831,  0.1473],
        [ 0.4460,  0.0169],
        [ 0.5242, -0.1913]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.4430,  0.5882],
        [ 0.4150,  0.0075],
        [ 0.6220, -0.1210],
        [-0.2967,  0.4129],
        [ 0.9220, -0.1844],
        [-0.1190,  0.4125],
        [ 0.4428, -0.1703],
        [ 1.3729, -0.8990],
        [ 0.3209,  0.0039],
        [ 0.8863, -0.4196],
        [-0.4724,  0.6790],
        [-0.1621,  0.2208]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-0.5534,  0.6582],
        [-0.3956,  0.7696],
        [ 0.0600,  0.3242],
        [ 0.1693,  0.3521],
        [-0.0359,  0.4423],
        [ 0.3765,  0.2735],
        [-0.0435,  0.3215],
        [-0.8882,  0.9737],
        [ 0.4731, -0.1680],
        [-0.4037,  0.6579],
        [-0.2557,  0.5046],
        [ 0.1704,  0.4588]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 0.3519, -0.0149],
        [-0.2441,  0.6572],
        [-0.1624,  0.7609],
        [-0.6011,  1.0244],
        [-0.1509,  0.1860],
        [ 0.0532,  0.2331],
        [ 1.1831, -0.6305],
        [-0.2126,  0.4038],
        [ 0.3060,  0.0595],
        [-0.0943,  0.4430],
        [ 0.1232,  0.2674],
        [ 0.4386, -0.0366]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 0.5133,  0.0642],
        [-0.0797,  0.4900],
        [-0.7589,  0.9866],
        [-0.8211,  1.0440],
        [ 0.0873,  0.3399],
        [ 0.2539,  0.3080],
        [ 0.1625,  0.0518],
        [-0.2395,  0.4552],
        [-0.6683,  1.0101],
        [-0.4040,  0.8797],
        [-0.0341,  0.4008],
        [-1.2539,  1.2795]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[-0.1666,  0.5359],
        [ 0.6826, -0.1477],
        [ 0.1447,  0.0372],
        [ 0.0388,  0.2338],
        [ 1.3743, -0.7258],
        [ 0.3572,  0.1035],
        [-0.5066,  0.6346],
        [ 0.3922,  0.0264],
        [ 0.0849,  0.1692],
        [-0.8543,  1.0877],
        [ 0.1099,  0.2126],
        [ 0.4071,  0.1928]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[ 0.1200,  0.1419],
        [ 0.9803, -0.3098],
        [-0.2180,  0.7845],
        [-0.5493,  0.7785],
        [ 0.0178,  0.3290],
        [ 0.9513, -0.4791],
        [-0.2517,  0.7244],
        [ 0.0220,  0.4014],
        [ 0.4594, -0.2352],
        [ 0.0943,  0.1438],
        [ 0.9157, -0.3722],
        [ 0.3162, -0.0750]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-0.5765,  0.9124],
        [-0.1165,  0.2461],
        [-0.4500,  0.5708],
        [ 0.5848, -0.2408],
        [ 0.0311,  0.3427],
        [-0.2651,  0.5189],
        [-0.5904,  0.8353],
        [ 0.1893,  0.1736],
        [-0.2917,  0.4982],
        [ 0.1914,  0.1502],
        [ 0.2955, -0.2392],
        [ 0.5990, -0.3329]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-0.7439,  0.9609],
        [ 0.2081,  0.2041],
        [-0.0576,  0.3270],
        [ 0.1718,  0.1116],
        [-0.1035,  0.3740],
        [ 0.2021,  0.1600],
        [-0.0634,  0.2933],
        [ 0.8223, -0.4338],
        [ 0.6364, -0.2041],
        [-0.5910,  0.9609],
        [ 0.3052, -0.1533],
        [-0.9226,  0.9960]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[ 0.3241, -0.0610],
        [ 0.7319, -0.3094],
        [ 0.3643,  0.0166],
        [-0.1254,  0.2252],
        [-0.0510,  0.0935],
        [-0.0263,  0.2670],
        [ 0.4613, -0.1599],
        [ 0.3476,  0.0094],
        [-0.1202,  0.5506],
        [ 0.1403,  0.2315],
        [ 0.0219,  0.2006],
        [ 0.0037,  0.3925]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[ 0.0649, -0.0118],
        [ 1.1549, -0.5588],
        [-0.0650,  0.4479],
        [ 0.9114, -0.4771],
        [-0.5056,  0.7181],
        [-0.4263,  0.6447],
        [ 0.2682,  0.1166],
        [ 0.3280,  0.1061],
        [ 0.8339, -0.4691],
        [-0.5741,  0.9382],
        [-0.0091,  0.4018],
        [ 0.4571, -0.2035]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-0.1487,  0.3699],
        [-0.7586,  0.8347],
        [ 0.7565, -0.4133],
        [ 1.0794, -0.5159],
        [-0.8948,  1.0361],
        [ 0.1956,  0.1772],
        [-0.2735,  0.4853],
        [ 0.0425,  0.1085],
        [ 0.5912, -0.3233],
        [ 0.2629,  0.1649],
        [ 0.7125, -0.4374],
        [ 0.4759, -0.2226]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.2232,  0.5342],
        [ 0.5227, -0.1109],
        [ 0.5663, -0.4006],
        [-0.2617,  0.3318],
        [ 0.2857,  0.0488],
        [-0.0829,  0.3329],
        [ 0.4039, -0.1405],
        [ 0.4282,  0.3403],
        [-0.0901,  0.2503],
        [ 1.0946, -0.6101],
        [-0.8879,  1.0015],
        [-0.6146,  0.8922]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-0.5185,  0.9733],
        [-0.0303,  0.2084],
        [-0.1949,  0.4147],
        [ 0.2217, -0.0090],
        [ 0.4580, -0.0017],
        [ 0.5818, -0.1089],
        [-0.1443,  0.4843],
        [-0.8965,  1.1224],
        [ 0.5397, -0.0734],
        [ 0.1761,  0.1267],
        [-0.2233,  0.5706],
        [-0.6634,  0.8186]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 0.1741,  0.2348],
        [-0.0676,  0.3176],
        [-1.0148,  1.3129],
        [-0.1995,  0.4042],
        [ 0.7248, -0.3855],
        [ 0.3938,  0.0170],
        [-0.7381,  0.7683],
        [-0.5072,  0.5443],
        [ 0.2456, -0.0651],
        [-0.0116,  0.2997],
        [-0.5213,  0.5552],
        [-0.2214,  0.7980]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[-0.0957,  0.3088],
        [ 1.0528, -0.8533],
        [ 0.7702, -0.4842],
        [ 0.4853,  0.0094],
        [-0.0657,  0.1648],
        [ 0.3530, -0.0101],
        [ 0.5064, -0.1005],
        [-0.0156,  0.2493],
        [ 0.0766,  0.2549],
        [-0.1309,  0.1240],
        [-0.6460,  0.6873],
        [-0.9442,  0.9866]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[-0.5744,  0.9915],
        [ 0.0597,  0.1901],
        [-0.3552,  0.5496],
        [ 1.0580, -0.5577],
        [ 0.4833, -0.2476],
        [-0.7080,  1.0599],
        [-0.5378,  0.7551],
        [-0.6820,  0.8424],
        [ 0.0875,  0.2474],
        [ 1.7459, -1.1267],
        [ 0.0303,  0.1225],
        [ 0.5170,  0.0236]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[ 0.0821,  0.1673],
        [ 0.6629, -0.1577],
        [ 0.0603,  0.1480],
        [-0.3419,  0.5232],
        [-0.3803,  0.6021],
        [-0.0654,  0.3695],
        [-1.0015,  0.9880],
        [ 0.1509,  0.0915],
        [ 0.2861,  0.3232],
        [ 1.0404, -0.5055],
        [ 1.2616, -0.5622],
        [ 0.8969, -0.6067]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[ 0.1273,  0.1877],
        [-0.1032,  0.1414],
        [-0.0506,  0.2817],
        [ 0.1756,  0.0383],
        [-0.1596,  0.4732],
        [-0.5907,  0.8097],
        [ 0.6817, -0.6318],
        [-0.2755,  0.6253],
        [ 0.8599, -0.6619],
        [ 0.6379, -0.3096],
        [ 0.4223, -0.1957],
        [ 0.2279,  0.0231]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[ 0.8801, -0.3566],
        [ 0.5442, -0.0433],
        [ 0.9779, -0.4411],
        [ 0.5788, -0.3369],
        [ 0.9857, -0.2878],
        [ 0.8277, -0.2898],
        [ 0.8077, -0.4098],
        [ 0.7825, -0.2517],
        [ 0.8442, -0.6341],
        [ 0.8294, -0.1309],
        [ 0.4033,  0.1015],
        [ 0.0138,  0.3767]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-0.4139,  0.7032],
        [ 0.1932,  0.4387],
        [-1.0232,  1.2432],
        [-0.9233,  1.1981],
        [-0.5361,  0.8572],
        [ 0.2626,  0.3973],
        [-0.5973,  0.9600],
        [-1.0993,  1.3081],
        [-0.4437,  0.8015],
        [-0.7550,  1.1719],
        [-0.2677,  0.5886],
        [-0.9438,  1.5078]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[ 0.2995,  0.2345],
        [ 0.2361,  0.3740],
        [-0.2458,  0.6927],
        [-0.6686,  1.1697],
        [-0.1653,  0.6507],
        [-0.6984,  1.0720],
        [-0.2259,  0.5643],
        [ 0.4741,  0.2271],
        [-0.3670,  0.7847],
        [-0.6018,  0.8700],
        [ 0.2925,  0.0656],
        [-0.4045,  0.7985]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-0.1284,  0.4645],
        [-0.1855,  0.3929],
        [ 0.4937,  0.0636],
        [-0.0244,  0.4701],
        [-1.0147,  1.3716],
        [-0.4048,  1.0385],
        [-0.6552,  1.0173],
        [-0.8842,  1.2959],
        [-0.7430,  1.2388],
        [-0.1709,  0.5893],
        [ 0.4151,  0.2369],
        [-0.1602,  0.8561]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.4107,  0.8246],
        [-0.7181,  0.9278],
        [-0.0623,  0.8186],
        [-0.4233,  0.6661],
        [ 0.4867,  0.1561],
        [ 0.3136, -0.0172],
        [ 0.1910,  0.2823],
        [-0.7640,  0.9627],
        [-0.9170,  1.0675],
        [ 0.2005,  0.3194],
        [-0.6529,  0.8590],
        [ 0.2022,  0.5918]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-0.6917,  1.1246],
        [-0.0948,  0.4014],
        [ 0.2298,  0.3047],
        [ 0.2986,  0.0063],
        [ 0.9980, -0.3087],
        [-0.2562,  0.5097],
        [-0.5181,  0.9687],
        [-0.9486,  1.1348],
        [-0.0296,  0.3938],
        [ 0.1619,  0.2609],
        [-0.2373,  0.5933],
        [-0.3287,  0.7613]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 0.9790, -0.4004],
        [ 0.4401,  0.0995],
        [-1.0585,  1.3993],
        [-0.5710,  0.7643],
        [ 0.2570,  0.1395],
        [ 0.6687, -0.0848],
        [-0.1956,  0.4006],
        [ 0.0548,  0.4057],
        [ 0.7445, -0.3624],
        [-0.5136,  0.6022],
        [-0.4176,  0.7214],
        [ 0.2697,  0.0753]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[-2.4993e-04,  3.7547e-01],
        [ 1.8880e-01,  1.4346e-01],
        [ 7.4567e-02,  5.8548e-01],
        [-2.9235e-01,  6.1861e-01],
        [ 3.1577e-01,  2.1518e-01],
        [-6.2961e-01,  8.0949e-01],
        [-2.2340e-01,  6.6325e-01],
        [ 2.3314e-01, -9.0753e-03],
        [ 2.0582e-01,  3.5382e-01],
        [-6.7785e-01,  8.7066e-01],
        [-2.8224e-01,  6.4331e-01],
        [-1.3165e-01,  6.1057e-01]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[-0.3772,  0.6417],
        [ 0.4417,  0.2078],
        [-0.0963,  0.4117],
        [ 0.4566,  0.1202],
        [-0.0775,  0.5646],
        [-0.1490,  0.6686],
        [-0.8743,  0.9618],
        [-0.2756,  0.9266],
        [-0.4337,  0.7326],
        [-0.8913,  1.0466],
        [ 0.0767,  0.4208],
        [ 0.7287, -0.2993]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-0.3776,  0.4976],
        [ 0.2469, -0.0168],
        [ 0.6245, -0.0490],
        [-0.4460,  0.6950],
        [-0.9857,  1.2186],
        [-0.5534,  0.9845],
        [-0.8059,  1.1608],
        [-0.6480,  0.8117],
        [ 1.1649, -0.5689],
        [ 0.1873,  0.2595],
        [ 0.7085, -0.0108],
        [-0.2069,  0.3149]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-0.0559,  0.2276],
        [-0.2309,  0.6411],
        [-1.2595,  1.4878],
        [-0.3874,  0.4256],
        [-0.4605,  0.8437],
        [ 0.4457,  0.0356],
        [ 0.0989,  0.2456],
        [-0.5816,  0.9761],
        [ 0.0715,  0.3073],
        [ 0.2599,  0.1311],
        [-0.1287,  0.2869],
        [ 1.2427, -0.6245]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-0.0222,  0.4541],
        [ 0.8284, -0.3655],
        [ 0.5438, -0.0497],
        [ 0.3225,  0.0836],
        [-0.4703,  1.0895],
        [ 1.0790, -0.5477],
        [ 0.4245, -0.0328],
        [-0.3388,  0.6506],
        [ 0.5379,  0.0833],
        [-0.2162,  0.6412],
        [-0.9977,  1.1244],
        [ 0.3522,  0.2075]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-0.1464,  0.3821],
        [-0.3720,  0.4807],
        [-0.3098,  0.6814],
        [-0.5418,  0.7413],
        [ 0.5860,  0.0223],
        [-0.0075,  0.5343],
        [-0.2542,  0.7638],
        [-0.2765,  0.4879],
        [-0.7167,  0.8941],
        [ 0.1903,  0.3271],
        [ 0.3490,  0.1879],
        [-0.1126,  0.4878]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-0.0886,  0.4493],
        [ 0.6608, -0.0797],
        [-0.9116,  1.2325],
        [ 0.1566,  0.0829],
        [ 0.5265,  0.1031],
        [-0.2304,  0.5192],
        [ 0.4139,  0.1083],
        [ 0.1792,  0.2804],
        [ 1.0846, -0.6522],
        [-0.4268,  0.5292],
        [ 0.2584,  0.2383],
        [-0.0989,  0.5393]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-0.0447,  0.3755],
        [ 0.0973,  0.4450],
        [ 1.2681, -0.4248],
        [-0.3108,  0.7004],
        [-0.5432,  0.6546],
        [-0.2470,  0.5348],
        [ 0.4156,  0.1029],
        [-0.5837,  0.9014],
        [-0.5648,  0.8622],
        [-0.0670,  0.4878],
        [ 0.0509,  0.2748],
        [-0.2608,  0.5384]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.9132,  0.9385],
        [ 0.0552,  0.4275],
        [ 0.0232,  0.4660],
        [-0.3832,  0.9815],
        [ 0.0791,  0.4222],
        [ 0.3308,  0.3674],
        [ 0.6749, -0.2263],
        [ 0.1568,  0.3725],
        [-0.5608,  1.0207],
        [ 0.4644,  0.0076],
        [-0.4517,  0.7084],
        [ 0.3498,  0.0906]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[ 0.0642,  0.3992],
        [ 0.7124, -0.0905],
        [-0.3977,  0.4449],
        [ 0.7552, -0.3212],
        [ 0.5054, -0.1439],
        [ 0.0061,  0.2865],
        [ 0.8836, -0.4365],
        [-0.3119,  0.5368],
        [ 0.5557, -0.2976],
        [ 0.1003,  0.1654],
        [-0.0917,  0.1881],
        [ 0.0599,  0.2620]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 0.1480,  0.3493],
        [ 0.1388,  0.0527],
        [-1.2602,  1.4737],
        [-0.8971,  1.0513],
        [ 1.0385, -0.4522],
        [ 1.5726, -0.9358],
        [-0.5007,  0.6968],
        [-0.5646,  0.9633],
        [ 0.0323,  0.2059],
        [-0.2009,  0.3609],
        [-0.4060,  0.7795],
        [-0.0709,  0.2771]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 1.0748, -0.5984],
        [ 0.6623, -0.2554],
        [ 0.6197, -0.2357],
        [ 0.1152,  0.3303],
        [ 0.0352,  0.3918],
        [-0.1035,  0.3948],
        [-0.1018,  0.3169],
        [ 0.0317,  0.0786],
        [-0.5975,  0.9580],
        [-0.1813,  0.5613],
        [ 0.0912,  0.5242],
        [ 0.3408, -0.2154]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[-0.2652,  0.6464],
        [-0.4637,  0.6856],
        [ 0.2846, -0.0400],
        [ 0.1870, -0.0149],
        [ 0.1814,  0.1980],
        [ 0.2972,  0.0199],
        [-0.5828,  0.8136],
        [ 0.8593, -0.3795],
        [ 0.2914,  0.0305],
        [ 0.2396,  0.1588],
        [-0.8796,  1.0189],
        [ 0.8818, -0.5848]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-0.2290,  0.3461],
        [-0.2095,  0.3702],
        [ 0.9882, -0.4894],
        [-0.6795,  0.7419],
        [-0.3461,  0.5873],
        [ 0.0943,  0.5080],
        [-1.1596,  1.5036],
        [-0.1387,  0.3780],
        [ 0.2625,  0.1566],
        [ 0.3272,  0.1798],
        [-0.0854,  0.5088],
        [ 0.8466, -0.4348]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[ 0.0145,  0.2327],
        [-0.3772,  0.6565],
        [-0.3376,  0.9463],
        [ 0.3345,  0.1524],
        [ 0.5394, -0.1817],
        [-0.3827,  0.6903],
        [-0.3625,  0.7213],
        [-0.0439,  0.5963],
        [-0.4398,  0.8829],
        [ 0.3801, -0.0725],
        [ 0.1137,  0.2275],
        [ 0.1534,  0.2764]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[ 0.0642,  0.3717],
        [-0.6605,  0.8023],
        [-0.0673,  0.2594],
        [-0.2328,  0.4828],
        [ 0.0069,  0.4564],
        [-0.2160,  0.5914],
        [-0.4564,  0.6408],
        [-0.3988,  0.5007],
        [-0.1997,  0.3991],
        [-0.5351,  0.9469],
        [ 0.3572, -0.0274],
        [-0.4983,  0.8884]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-0.9275,  1.0586],
        [-0.0298,  0.2292],
        [-0.1006,  0.3791],
        [ 0.2038,  0.2097],
        [ 0.2090,  0.0681],
        [-0.5004,  0.5913],
        [ 0.3748,  0.1639],
        [-0.3893,  0.3564],
        [ 0.3245,  0.0905],
        [-0.3194,  0.6103],
        [ 0.8896, -0.4070],
        [ 0.2959,  0.1496]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-0.6902,  0.7407],
        [-0.0698,  0.3381],
        [-1.3539,  1.5292],
        [-0.5871,  0.8723],
        [ 0.1524,  0.1404],
        [-0.4227,  0.7751],
        [ 0.0610,  0.4685],
        [-0.1545,  0.6946],
        [ 0.4553, -0.2161],
        [-0.1960,  0.5178],
        [-0.1036,  0.4731],
        [-0.7748,  0.9511]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-3.7769e-01,  4.0368e-01],
        [-7.4788e-01,  9.9178e-01],
        [ 9.1761e-01, -5.1242e-01],
        [-5.5350e-01,  7.0626e-01],
        [-6.7902e-01,  8.9628e-01],
        [ 7.3011e-02,  3.2773e-01],
        [-6.1575e-02,  3.0633e-01],
        [-7.7359e-01,  1.0371e+00],
        [ 2.5354e-01,  5.4385e-02],
        [-6.2458e-04,  4.5597e-01],
        [-1.1680e-01,  3.3088e-01],
        [ 3.3868e-01,  1.2991e-01]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.3218,  0.6294],
        [-0.1114,  0.4014],
        [-0.2621,  0.5332],
        [-0.4024,  0.6079],
        [ 0.1619,  0.3318],
        [ 0.4302, -0.0507],
        [ 1.6360, -1.2180],
        [ 0.2988,  0.0176],
        [ 0.0459,  0.5062],
        [-0.4202,  0.7220],
        [-0.3289,  0.4974],
        [-0.4710,  0.5940]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-3.9719e-02, -8.5434e-02],
        [ 6.0159e-01, -3.3413e-01],
        [ 2.9392e-01, -2.1284e-01],
        [ 5.8641e-04,  3.0385e-01],
        [ 4.3540e-01,  4.2166e-02],
        [-3.4331e-01,  5.8949e-01],
        [ 7.3466e-02,  3.5842e-01],
        [-7.9683e-01,  8.9407e-01],
        [-1.2458e-01,  5.1078e-01],
        [-3.8278e-01,  7.3380e-01],
        [-1.0947e-01,  2.2841e-01],
        [ 2.4888e-01,  1.7935e-01]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 0.7815, -0.4550],
        [ 0.0367,  0.0563],
        [-0.7619,  1.0137],
        [-0.3467,  0.6011],
        [ 0.3919, -0.1622],
        [-0.4606,  0.7190],
        [-0.1045,  0.1538],
        [-0.1685,  0.2969],
        [ 1.0179, -0.6300],
        [-0.4638,  0.7064],
        [-0.1861,  0.5669],
        [-0.1278,  0.4556]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 1.2687, -0.9536],
        [ 0.3191,  0.2373],
        [ 0.8296, -0.2492],
        [-0.1285,  0.6705],
        [-0.3944,  0.7448],
        [ 0.8766, -0.3470],
        [-0.3343,  0.5077],
        [ 0.3633,  0.0164],
        [-0.0188,  0.3352],
        [-0.9118,  1.1888],
        [-0.3982,  0.5633],
        [-0.9921,  0.9905]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[-0.1369,  0.3222],
        [ 0.0604,  0.0511],
        [ 0.2859, -0.0013],
        [ 0.8189, -0.6871],
        [ 0.3231,  0.0223],
        [ 0.0902, -0.0717],
        [-0.2748,  0.3267],
        [-0.0501,  0.4814],
        [-0.4325,  0.3838],
        [-0.8167,  1.0357],
        [-0.7466,  0.8282],
        [ 0.4284, -0.1878]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[ 0.4471, -0.0626],
        [ 0.3743,  0.0222],
        [ 0.6077, -0.2090],
        [-0.4470,  0.5885],
        [-0.3636,  0.5393],
        [-0.5751,  0.9679],
        [-0.4463,  0.7440],
        [ 0.3425,  0.3218],
        [ 1.1641, -0.9027],
        [-1.0218,  1.2330],
        [ 0.5646, -0.1856],
        [ 1.2392, -1.1534]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[ 0.5332, -0.2888],
        [ 0.2725,  0.1978],
        [-0.5738,  0.8821],
        [ 0.2142,  0.1129],
        [ 0.7388, -0.6139],
        [ 0.3887,  0.0454],
        [-0.7360,  0.9327],
        [-0.1101,  0.3064],
        [-0.0563,  0.1066],
        [-0.3122,  0.6483],
        [ 0.6657, -0.2473],
        [-0.6128,  0.8544]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[ 0.0699,  0.0489],
        [-0.7324,  0.8490],
        [ 0.6221, -0.3810],
        [-0.3402,  0.6057],
        [-0.2556,  0.4600],
        [ 0.4907, -0.1203],
        [ 0.1369,  0.0945],
        [-0.5556,  0.7764],
        [ 0.3062,  0.0103],
        [ 0.1935,  0.2178],
        [ 0.8131, -0.4334],
        [ 1.1023, -0.7324]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[ 0.2234,  0.0892],
        [-0.1093,  0.3068],
        [-0.5255,  0.6655],
        [ 0.3115,  0.0283],
        [-0.2612,  0.3948],
        [ 1.0598, -0.5552],
        [ 0.7411, -0.3521],
        [ 0.7295, -0.4141],
        [-1.1719,  1.2862],
        [ 0.1935,  0.4621],
        [ 0.8097, -0.2689],
        [-0.4919,  0.4440]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[ 0.1696,  0.1437],
        [-0.2095,  0.4645],
        [ 0.1644,  0.1022],
        [-0.4657,  0.7614],
        [ 0.7950, -0.4000],
        [-0.4522,  0.6765],
        [ 0.3447,  0.1393],
        [ 0.0521,  0.2439],
        [ 0.1815,  0.1797],
        [ 0.4294, -0.1283],
        [ 0.5442, -0.2791],
        [-0.2505,  0.4838]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[ 3.0010e-01,  1.7394e-01],
        [-3.8733e-01,  4.5814e-01],
        [ 1.6240e+00, -1.3297e+00],
        [ 7.8425e-05,  9.3868e-02],
        [-1.3271e+00,  1.5756e+00],
        [-1.5804e-01,  3.8219e-01],
        [-2.5476e-02,  6.0766e-01],
        [-1.7003e+00,  1.8683e+00],
        [-1.4863e+00,  1.7708e+00],
        [-2.6616e-01,  3.7126e-01],
        [-3.6243e-01,  6.2200e-01],
        [ 6.2842e-01, -1.6900e-01]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.2105,  0.5267],
        [ 0.2059, -0.2079],
        [ 0.1365, -0.0035],
        [-0.2952,  0.4053],
        [-1.0680,  1.3750],
        [-0.2286,  0.6398],
        [ 0.1447,  0.0201],
        [ 0.1070,  0.2446],
        [-0.0032,  0.3757],
        [ 0.5817, -0.2361],
        [-0.6465,  0.6466],
        [-0.8366,  0.8957]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-1.1040,  1.4199],
        [-0.7105,  0.7537],
        [ 1.0176, -0.7191],
        [-0.8348,  0.8632],
        [ 0.3640, -0.4031],
        [-0.4438,  0.6151],
        [ 0.0346,  0.2329],
        [-0.5227,  0.6913],
        [-0.5222,  0.5834],
        [-1.0045,  0.9369],
        [ 0.1231,  0.1137],
        [-1.1629,  1.3039]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[-0.2089,  0.4747],
        [ 0.0882,  0.2832],
        [-0.5392,  0.9596],
        [-1.7669,  1.7714],
        [ 0.4523, -0.2327],
        [ 0.0532,  0.3346],
        [-0.6619,  0.8383],
        [-0.8598,  0.9643],
        [ 0.2880, -0.0248],
        [-0.9997,  1.2684],
        [-0.6044,  0.8652],
        [-0.0773,  0.3178]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 0.4158, -0.0171],
        [ 0.1611,  0.2594],
        [ 0.3797, -0.0222],
        [-0.0194,  0.1720],
        [-0.3132,  0.3735],
        [ 0.0951,  0.3655],
        [-0.8798,  0.8854],
        [-0.7851,  1.1085],
        [-0.5728,  0.8866],
        [-0.3039,  0.3321],
        [-0.5623,  0.8097],
        [-0.8669,  1.2120]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[-0.0805,  0.4200],
        [-0.1989,  0.2886],
        [ 0.0428, -0.0020],
        [-0.1379,  0.3885],
        [-1.0937,  1.1594],
        [-0.5276,  0.8032],
        [-0.3863,  0.5598],
        [-0.2693,  0.5844],
        [ 0.1329,  0.2120],
        [ 0.1907,  0.1807],
        [-0.0926,  0.3290],
        [-0.1728,  0.3856]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-0.0999,  0.3118],
        [-0.0787,  0.4046],
        [ 0.1439,  0.0717],
        [-0.6468,  0.7948],
        [-0.3441,  0.4972],
        [-0.9172,  1.3038],
        [-0.7340,  1.2002],
        [-0.4192,  0.8642],
        [ 1.6586, -1.0844],
        [-0.7363,  0.9466],
        [ 0.2538,  0.1447],
        [ 1.8305, -1.2078]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-0.5503,  0.7644],
        [ 0.1828,  0.0687],
        [-1.0583,  1.2477],
        [-0.2573,  0.4114],
        [ 0.2420,  0.0168],
        [ 0.3758,  0.0040],
        [-0.5925,  0.8929],
        [-0.1175,  0.0613],
        [ 0.0511,  0.0109],
        [-0.2196,  0.2622],
        [-0.9418,  0.9987],
        [ 1.3679, -0.9766]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-0.6066,  0.8755],
        [ 0.2561,  0.1182],
        [ 0.5524, -0.3444],
        [ 0.7884, -0.3237],
        [-0.1196,  0.3351],
        [ 0.5469, -0.4058],
        [ 0.8346, -0.6556],
        [ 0.8923, -0.2959],
        [ 1.0732, -0.5543],
        [-0.7601,  1.0092],
        [ 0.1635, -0.0500],
        [ 0.7475, -0.2969]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[ 0.9360, -0.5926],
        [ 0.5710, -0.3632],
        [-0.8084,  0.8216],
        [-0.0028,  0.0320],
        [ 0.3902, -0.2758],
        [ 0.3936,  0.1930],
        [ 0.4622, -0.0913],
        [-0.4421,  0.5634],
        [-0.3113,  0.4568],
        [-0.4963,  0.8582],
        [ 0.0132,  0.5081],
        [ 0.9842, -0.3872]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-0.1886,  0.3241],
        [ 0.9237, -0.4519],
        [ 0.1802,  0.2124],
        [ 0.5788, -0.3997],
        [-0.2768,  0.6121],
        [-0.1987,  0.6005],
        [ 0.8613, -0.3335],
        [-0.3806,  0.5416],
        [ 0.1862,  0.0593],
        [-0.9041,  0.9477],
        [ 0.3870,  0.1311],
        [-0.7544,  1.1594]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-0.3026,  0.6171],
        [ 0.3906,  0.0285],
        [ 1.6692, -1.2186],
        [ 0.8802, -0.4695],
        [-0.3050,  0.6487],
        [-0.2249,  0.4676],
        [-0.1831,  0.2860],
        [-0.8758,  1.0688],
        [-0.6295,  0.7873],
        [ 0.3487, -0.1899],
        [ 1.1453, -0.5577],
        [-0.6289,  0.8558]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[ 0.2186,  0.1186],
        [ 0.3452, -0.0377],
        [ 0.4941, -0.1092],
        [-0.2089,  0.5714],
        [ 1.5197, -1.0180],
        [ 0.7283, -0.3078],
        [ 1.5515, -1.1052],
        [ 0.8459, -0.5741],
        [ 0.1989,  0.1198],
        [ 0.1763, -0.1294],
        [-0.7274,  0.9763],
        [ 0.1787,  0.0228]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-0.0604,  0.0496],
        [ 0.1615,  0.1073],
        [ 0.2044,  0.1563],
        [ 0.9247, -0.6253],
        [ 0.2449,  0.3983],
        [ 1.5826, -0.9875],
        [-0.6461,  1.0110],
        [ 0.3527,  0.0226],
        [ 0.1919, -0.2201],
        [ 0.0685,  0.0934],
        [-0.1833,  0.0911],
        [-0.2436,  0.4286]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 0.3878, -0.1849],
        [-0.1347,  0.5541],
        [ 0.2118,  0.2148],
        [ 0.0849,  0.1957],
        [ 0.2121,  0.1575],
        [-0.0073,  0.1303],
        [ 0.0116,  0.4338],
        [-0.6489,  0.9430],
        [-0.1014,  0.4496],
        [-0.2172,  0.3060],
        [-0.0098,  0.1695],
        [ 0.0022,  0.2543]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 1.3858, -1.1043],
        [-1.0829,  1.0827],
        [ 0.4388, -0.0868],
        [ 0.3966, -0.0747],
        [ 1.7876, -1.2737],
        [ 1.0971, -0.6602],
        [ 0.1957,  0.1728],
        [-0.0368,  0.1067],
        [ 0.3258,  0.0164],
        [ 0.1987, -0.0057],
        [ 0.2975,  0.0820],
        [ 0.3266,  0.1770]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[-0.4303,  0.6364],
        [ 0.0158,  0.2478],
        [ 0.2424,  0.0500],
        [ 0.4643,  0.0904],
        [ 0.0068,  0.2591],
        [ 0.1743,  0.2974],
        [-0.2384,  0.5586],
        [-0.5803,  0.8823],
        [ 0.3050, -0.0127],
        [ 0.3789, -0.0901],
        [-0.3078,  0.6700],
        [ 0.8003, -0.2334]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-0.5436,  0.8303],
        [ 0.4553, -0.1314],
        [ 0.0453,  0.1854],
        [ 0.0308,  0.4106],
        [-1.1943,  1.3451],
        [-0.0446,  0.4313],
        [-0.6321,  1.1645],
        [-0.8396,  1.1193],
        [ 1.6041, -1.0968],
        [-0.0223,  0.4678],
        [ 0.0317,  0.3182],
        [ 0.9105, -0.7175]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-0.8156,  0.9890],
        [-0.5039,  0.7241],
        [-0.9760,  1.2199],
        [ 0.4998, -0.3144],
        [-0.0787,  0.3312],
        [-0.0377,  0.2791],
        [ 0.7190, -0.4014],
        [ 0.2641,  0.2074],
        [-0.0177,  0.1901],
        [-0.0830,  0.1794],
        [ 0.2534, -0.0528],
        [ 0.8380, -0.6392]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[ 0.4237,  0.0520],
        [ 0.2225,  0.0533],
        [ 0.1276,  0.1044],
        [ 1.1904, -0.6551],
        [-0.5160,  0.6241],
        [-0.1134,  0.4419],
        [-0.2234,  0.4830],
        [-0.9756,  0.9101],
        [ 0.7818, -0.3683],
        [-1.2601,  1.5388],
        [-0.5086,  0.8043],
        [-0.8972,  1.1380]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-0.3498,  0.3665],
        [ 0.4060, -0.0214],
        [-0.6375,  0.9607],
        [-0.4684,  0.7250],
        [ 0.0485,  0.2063],
        [-0.1891,  0.2829],
        [-0.1602,  0.3970],
        [-0.9269,  1.0552],
        [ 0.1234,  0.2487],
        [-0.6956,  0.9811],
        [-0.4005,  0.5621],
        [-0.5151,  0.6530]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-0.1600,  0.6050],
        [ 1.0289, -0.6992],
        [ 0.2857,  0.0512],
        [ 1.1721, -0.7390],
        [ 1.1738, -0.7121],
        [ 0.2716,  0.1063],
        [ 1.0422, -0.6387],
        [ 0.3806, -0.0786],
        [ 0.3304,  0.1510],
        [-0.7350,  0.7616],
        [ 1.7147, -1.3377],
        [ 0.5131, -0.1498]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-0.8878,  1.0712],
        [-0.7002,  1.0317],
        [ 1.0957, -0.7160],
        [ 0.4214, -0.1790],
        [-0.3412,  0.3301],
        [ 0.2283, -0.0838],
        [ 0.0561,  0.3530],
        [-1.8872,  1.9944],
        [-0.8114,  1.1807],
        [-0.2472,  0.6005],
        [ 0.4816, -0.0808],
        [-0.1631,  0.3969]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.6632,  1.0900],
        [ 0.8485, -0.4833],
        [-0.9848,  1.1987],
        [-1.2193,  1.4389],
        [-0.1241,  0.3918],
        [-1.2662,  1.2892],
        [ 0.6039, -0.3534],
        [ 0.7287, -0.3676],
        [ 0.0788, -0.0255],
        [ 0.2823, -0.1708],
        [-1.3057,  1.2845],
        [ 0.0797,  0.2751]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[ 0.4112, -0.1529],
        [ 0.1484,  0.1452],
        [-0.6144,  0.8284],
        [-0.8783,  0.9511],
        [ 1.3341, -1.0560],
        [-0.6128,  0.9403],
        [-0.5590,  0.8733],
        [-0.4837,  0.7712],
        [-0.6151,  0.7334],
        [-1.0987,  1.2433],
        [-0.3692,  0.7756],
        [-1.3826,  1.4380]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 1.3157, -0.8662],
        [ 0.8421, -0.2865],
        [-0.6729,  1.0081],
        [-1.3718,  1.5035],
        [ 0.1265, -0.0038],
        [-0.2668,  0.6002],
        [-0.8019,  0.8071],
        [-0.0786,  0.3455],
        [-0.2128,  0.4466],
        [-0.0763,  0.4208],
        [ 0.0339,  0.2839],
        [ 0.3416, -0.0999]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 0.7078, -0.3092],
        [-0.2202,  0.5936],
        [ 0.2810, -0.1155],
        [ 0.5103,  0.0254],
        [ 0.1286,  0.3089],
        [ 0.3763,  0.0870],
        [-0.0532,  0.1714],
        [-1.0421,  1.1235],
        [ 0.1942,  0.1474],
        [-1.3862,  1.4698],
        [-0.7460,  1.0536],
        [-1.3886,  1.6226]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[ 0.3107,  0.1500],
        [ 0.2717, -0.0617],
        [ 0.2780, -0.0582],
        [ 0.4906, -0.1710],
        [ 0.9356, -0.5904],
        [-0.7406,  0.7272],
        [-0.2925,  0.4230],
        [ 1.0026, -0.6039],
        [ 0.5046, -0.2976],
        [-0.3845,  0.5918],
        [-0.6443,  0.8213],
        [ 0.1737,  0.1095]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-0.1999,  0.4976],
        [ 0.1671,  0.0051],
        [-0.6572,  0.9398],
        [-0.2265,  0.4568],
        [-1.0269,  1.2681],
        [-0.6790,  0.9318],
        [-1.1576,  1.3649],
        [-1.3097,  1.2952],
        [ 0.9805, -0.8835],
        [-0.9830,  1.1222],
        [ 1.1979, -0.7830],
        [ 0.2398, -0.1345]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-0.2508,  0.7436],
        [-0.0233,  0.1324],
        [-0.7392,  0.9214],
        [ 0.4152, -0.1216],
        [-0.0886,  0.3024],
        [-0.0710,  0.2832],
        [-0.4849,  0.6668],
        [-0.6311,  0.8921],
        [ 0.2703, -0.0898],
        [ 0.3514, -0.2664],
        [ 1.1936, -0.7643],
        [ 0.2958,  0.0266]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[ 0.6732, -0.2472],
        [-0.4623,  0.5748],
        [ 0.1138,  0.1464],
        [-0.1757,  0.4064],
        [ 0.0296,  0.2887],
        [ 0.2254,  0.0461],
        [ 0.2495, -0.1143],
        [-0.2509,  0.5703],
        [ 0.6794, -0.1890],
        [-1.0795,  1.3715],
        [-0.3039,  0.4408],
        [ 0.3290, -0.1450]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-0.3586,  0.5829],
        [ 1.0039, -0.6387],
        [-0.2158,  0.4128],
        [ 0.4022, -0.3193],
        [-0.0065,  0.4604],
        [ 0.6841, -0.4771],
        [-0.6614,  0.7171],
        [ 0.3768, -0.1541],
        [ 0.4283,  0.0797],
        [ 0.4118, -0.2169],
        [-0.2679,  0.6355],
        [-0.2804,  0.6243]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[ 0.3488, -0.1013],
        [-0.5309,  0.9047],
        [ 0.9710, -0.3000],
        [ 0.0280,  0.3164],
        [ 1.3758, -1.0821],
        [ 0.2630,  0.2786],
        [-0.4061,  0.5399],
        [-0.2635,  0.5287],
        [ 0.0353,  0.3613],
        [-0.5936,  0.8167],
        [-0.3696,  0.4227],
        [ 0.5178, -0.0119]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-0.9654,  0.9322],
        [ 0.5796, -0.2999],
        [ 0.9054, -0.5448],
        [ 0.0385,  0.0445],
        [-1.2312,  1.3439],
        [ 0.0539,  0.2865],
        [-1.7961,  1.6120],
        [-1.7962,  1.8850],
        [-0.8988,  0.9494],
        [-1.1006,  1.2478],
        [-0.7512,  0.9225],
        [ 0.4748, -0.2441]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.4688,  0.7038],
        [ 0.5904, -0.2395],
        [ 0.0082,  0.2850],
        [ 1.0624, -0.8342],
        [-0.9153,  1.3160],
        [-0.4206,  0.4763],
        [ 0.2936, -0.0527],
        [ 0.3359, -0.1621],
        [-0.2802,  0.4860],
        [ 0.2945,  0.0350],
        [-1.2851,  1.4323],
        [-0.5273,  0.6908]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-1.5942,  1.6985],
        [ 0.2667, -0.0595],
        [-0.6766,  0.9555],
        [-0.0784,  0.4257],
        [-0.4773,  0.4194],
        [-1.2560,  1.4026],
        [-0.4468,  0.7757],
        [ 0.1686,  0.2639],
        [-0.4609,  0.5609],
        [ 0.1677,  0.2122],
        [ 0.3542, -0.1063],
        [ 0.1522,  0.2992]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 0.2632,  0.1926],
        [ 0.6007, -0.4092],
        [ 0.1387,  0.1093],
        [-1.2274,  1.4640],
        [ 1.1474, -0.5853],
        [-0.8244,  1.2299],
        [-0.4492,  0.6040],
        [-0.3000,  0.5294],
        [ 0.0111,  0.1998],
        [ 0.8648, -0.5897],
        [ 0.3308,  0.1570],
        [-0.3540,  0.6369]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[-0.5861,  0.7634],
        [-0.2422,  0.7220],
        [ 0.1302,  0.1185],
        [ 1.1965, -0.7299],
        [-1.2737,  1.5474],
        [ 0.5644, -0.3849],
        [-0.8207,  0.6785],
        [-1.3071,  1.4146],
        [-0.8237,  1.0466],
        [ 0.0437,  0.2438],
        [-0.7035,  0.9189],
        [-1.9432,  2.1364]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[ 0.6556, -0.3246],
        [ 0.4020, -0.0080],
        [ 0.0787,  0.3833],
        [-0.9647,  1.0809],
        [ 0.3553,  0.2166],
        [-0.0085,  0.5450],
        [-0.3969,  0.6810],
        [-1.1420,  1.2498],
        [ 1.2852, -0.8247],
        [-0.5822,  0.5976],
        [-0.9632,  1.1927],
        [-0.7613,  1.0096]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-0.4263,  0.8265],
        [ 0.0317,  0.1335],
        [ 0.3996, -0.0224],
        [-0.5749,  0.7930],
        [-0.8127,  1.0352],
        [ 0.1557,  0.1435],
        [-0.1989,  0.4230],
        [-0.5696,  0.7866],
        [ 1.6365, -1.0982],
        [-0.2124,  0.5787],
        [ 0.5382, -0.2469],
        [-0.0068,  0.3439]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-1.6227,  1.6971],
        [-1.1554,  1.4290],
        [-1.1367,  1.2037],
        [ 0.8623, -0.7489],
        [ 1.9331, -1.6759],
        [-0.3471,  0.5870],
        [-0.2370,  0.6386],
        [-0.4864,  0.7283],
        [ 0.8173, -0.5095],
        [-0.5619,  0.6573],
        [ 0.2806, -0.0919],
        [ 0.2935, -0.3524]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-3.5715e-01,  5.8276e-01],
        [-3.2482e-01,  5.7564e-01],
        [ 5.3131e-01, -3.2388e-01],
        [ 8.3982e-03,  8.9217e-02],
        [-1.9931e-01,  3.7356e-01],
        [-1.3819e-01,  4.1792e-01],
        [ 7.2294e-01, -3.2827e-01],
        [-7.3423e-01,  1.0592e+00],
        [ 1.1670e+00, -7.2993e-01],
        [-9.3644e-01,  1.1477e+00],
        [-1.1565e-03,  1.5401e-01],
        [-1.1171e+00,  1.1024e+00]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[ 1.1675, -0.9136],
        [ 1.0578, -0.7013],
        [-0.5155,  0.7294],
        [-0.4085,  0.5826],
        [ 0.3573, -0.0274],
        [ 0.0051,  0.2223],
        [ 0.9430, -0.5786],
        [-0.3660,  0.5735],
        [-0.6537,  0.7159],
        [ 0.2712, -0.1438],
        [-1.1425,  1.1113],
        [ 0.3343, -0.1704]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[ 0.3081, -0.0341],
        [ 0.9307, -0.7119],
        [-0.2331,  0.2877],
        [-0.0179,  0.1883],
        [ 0.7087, -0.4825],
        [ 0.3782, -0.1881],
        [ 0.1665,  0.0499],
        [ 1.9548, -1.2250],
        [-0.0575,  0.1466],
        [-0.9704,  1.1141],
        [ 0.8844, -0.5033],
        [-1.2252,  1.4839]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-0.9646,  1.1394],
        [-0.5602,  0.5994],
        [ 1.1721, -0.9688],
        [ 0.3955, -0.1533],
        [-0.4087,  0.3964],
        [ 0.1268,  0.2664],
        [-0.5279,  0.7351],
        [-1.3716,  1.3790],
        [-0.3821,  0.4415],
        [-1.0893,  1.2024],
        [ 0.6338, -0.3982],
        [ 0.8077, -0.7978]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.2053,  0.5692],
        [-0.2140,  0.3319],
        [-0.4899,  0.6039],
        [-0.7590,  0.7914],
        [-0.8828,  1.2024],
        [-0.9589,  1.1352],
        [-0.4485,  0.7593],
        [ 0.6568, -0.3810],
        [-1.0619,  1.1839],
        [-0.2852,  0.4520],
        [-0.7947,  0.7574],
        [-1.0486,  1.1875]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-0.4684,  0.8254],
        [-0.6935,  0.9094],
        [ 0.6057, -0.2303],
        [ 0.5735, -0.4683],
        [ 1.3447, -0.9334],
        [ 0.7474, -0.4181],
        [-1.4417,  1.6032],
        [ 0.8946, -0.4843],
        [-1.1622,  1.2883],
        [ 0.7968, -0.4060],
        [ 0.7600, -0.7617],
        [ 0.2128,  0.1381]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 1.1529, -1.0004],
        [ 1.3858, -0.8787],
        [-1.2073,  1.2697],
        [-1.2670,  1.4032],
        [ 0.0497,  0.0656],
        [-0.6375,  0.7479],
        [-0.4856,  0.6088],
        [-1.0003,  1.1525],
        [-0.2756,  0.4172],
        [-0.2621,  0.2783],
        [-0.2337,  0.3934],
        [ 0.2919, -0.0649]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 0.4363,  0.1121],
        [-1.5741,  1.4955],
        [-0.2728,  0.3206],
        [-0.4122,  0.7309],
        [-0.4062,  0.6662],
        [-0.1695,  0.5043],
        [-0.3168,  0.4604],
        [-0.4577,  0.5063],
        [-0.8962,  1.1768],
        [ 0.4000, -0.1010],
        [-1.4636,  1.4432],
        [-1.7734,  1.7629]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[ 1.0319, -0.8234],
        [-0.0199,  0.3074],
        [-0.8923,  1.0902],
        [ 1.1141, -0.8706],
        [ 0.0604,  0.1237],
        [ 0.6578, -0.5939],
        [-0.9402,  1.1319],
        [-1.0435,  1.4614],
        [ 0.0521,  0.0875],
        [ 0.0383,  0.1022],
        [-0.8272,  1.1095],
        [-0.1561,  0.3106]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[ 0.4470, -0.2249],
        [ 0.2261, -0.1522],
        [-0.6823,  0.7001],
        [-1.2682,  1.4488],
        [-0.7698,  0.5940],
        [ 0.4610, -0.1265],
        [-0.8075,  0.8552],
        [-1.0965,  1.2996],
        [ 1.4067, -1.1428],
        [ 0.2264,  0.1692],
        [-0.0453,  0.2774],
        [ 1.9768, -1.4597]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-1.2289,  1.4915],
        [-2.3591,  2.1738],
        [-1.5638,  1.6220],
        [-0.2994,  0.5444],
        [ 0.7398, -0.5276],
        [-1.8355,  2.0022],
        [-1.5644,  1.6919],
        [-1.1675,  1.4945],
        [-0.5318,  0.4329],
        [-0.5819,  0.4943],
        [-0.1827,  0.4112],
        [-0.8884,  1.1100]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-1.3802,  1.4880],
        [-0.7361,  0.8764],
        [-1.1835,  1.2572],
        [-1.2056,  1.4402],
        [-1.1925,  1.3337],
        [-0.9966,  1.1409],
        [-0.6924,  0.8950],
        [-1.7422,  1.9840],
        [-0.4511,  0.7658],
        [-1.3649,  1.8170],
        [-0.5199,  0.8351],
        [-0.7387,  0.9415]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-0.6195,  0.8067],
        [-0.2626,  0.4878],
        [-1.7612,  1.7698],
        [-0.1875,  0.2189],
        [ 0.6190, -0.3064],
        [-0.3294,  0.4855],
        [-0.7031,  0.7484],
        [-1.2787,  1.2411],
        [-1.3918,  1.5263],
        [-0.6638,  0.7899],
        [-1.2826,  1.4638],
        [-0.3177,  0.3930]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-0.2870,  0.5130],
        [ 0.0166,  0.1388],
        [-0.1106,  0.2405],
        [ 0.1924,  0.0451],
        [ 0.2163,  0.1804],
        [-0.2226,  0.4072],
        [ 0.9049, -0.6062],
        [ 1.2286, -0.4820],
        [ 0.0219,  0.5268],
        [-0.4202,  0.5997],
        [-0.1172,  0.3550],
        [ 0.1847, -0.2166]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-0.2811,  0.4499],
        [-0.3116,  0.6333],
        [ 0.3288, -0.1537],
        [-0.5821,  0.7084],
        [-0.4668,  0.7437],
        [ 0.2552, -0.0039],
        [-0.7120,  0.8981],
        [-1.9525,  1.8890],
        [ 0.1363,  0.0278],
        [-1.1441,  1.3188],
        [ 0.2026,  0.1586],
        [ 0.5176, -0.1537]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.8418,  1.0307],
        [-0.5648,  0.7915],
        [-0.0876,  0.5908],
        [-1.3210,  1.4871],
        [ 0.3395,  0.1053],
        [-1.2381,  1.2694],
        [ 0.7926, -0.5212],
        [ 0.9321, -0.6340],
        [-0.5374,  0.9302],
        [-0.4580,  0.6605],
        [-0.7923,  1.1263],
        [-0.8584,  1.1474]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-0.7508,  1.0132],
        [-0.0127,  0.1445],
        [-0.6709,  0.9289],
        [-0.7153,  0.8180],
        [-0.0988,  0.2039],
        [-0.8763,  1.0758],
        [-0.3130,  0.7411],
        [-1.0083,  1.1163],
        [-0.3429,  0.1826],
        [-1.0553,  1.0586],
        [ 0.1194,  0.1298],
        [ 0.7059, -0.4291]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 0.0801,  0.1299],
        [-0.5332,  0.6777],
        [-1.2918,  1.4407],
        [-1.8687,  1.9058],
        [ 0.0500,  0.2054],
        [-0.5118,  0.6212],
        [-0.3714,  0.7722],
        [-0.2395,  0.3770],
        [ 0.0172,  0.2648],
        [-0.0538,  0.3846],
        [-0.4640,  0.8685],
        [ 0.3150, -0.0028]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[-0.7958,  1.1034],
        [ 0.2757, -0.0485],
        [ 0.0036,  0.0881],
        [ 0.4916, -0.2078],
        [-0.8290,  1.0897],
        [-0.1446,  0.3846],
        [ 0.1330,  0.2052],
        [-0.5543,  0.6810],
        [ 0.3222,  0.0813],
        [-0.5311,  0.7999],
        [-1.9999,  2.0395],
        [-0.9982,  1.2296]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[ 0.8275, -0.4913],
        [-0.2291,  0.6093],
        [-1.7717,  1.8653],
        [-0.4510,  0.5256],
        [ 0.7860, -0.3817],
        [ 0.5487, -0.2734],
        [-1.4958,  1.6732],
        [-1.0129,  1.1782],
        [ 0.6656, -0.4353],
        [ 0.2146,  0.1543],
        [-1.5035,  1.7449],
        [ 0.6447, -0.4503]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[ 1.4120, -1.1412],
        [ 0.6140, -0.4361],
        [ 1.1978, -0.8080],
        [ 0.0456,  0.2254],
        [-0.9865,  1.1908],
        [-0.6392,  0.8639],
        [-1.1028,  1.2710],
        [-2.1118,  1.9789],
        [ 2.1006, -1.6246],
        [-0.1267,  0.4251],
        [ 0.3425,  0.1961],
        [ 0.5348, -0.0950]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-0.2238,  0.6356],
        [-1.0371,  0.9825],
        [-1.3623,  1.4099],
        [ 0.9213, -0.4999],
        [ 0.7268, -0.4008],
        [-0.7065,  0.9587],
        [-0.8645,  0.8952],
        [-0.4481,  0.6254],
        [ 1.9997, -1.5681],
        [ 0.8976, -0.7351],
        [ 1.0472, -0.6988],
        [ 1.0062, -0.7860]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[ 0.3611, -0.1092],
        [ 0.1855,  0.2311],
        [-0.7251,  0.9193],
        [-0.1541,  0.1924],
        [-0.0185,  0.3492],
        [-0.1457,  0.4129],
        [-0.4937,  0.6006],
        [ 0.3637,  0.0395],
        [ 1.1370, -0.6803],
        [-1.0224,  1.2380],
        [-0.2440,  0.4124],
        [-0.7350,  1.1765]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-0.5151,  0.7062],
        [ 1.9894, -1.5761],
        [-1.0927,  1.2029],
        [-0.2935,  0.4675],
        [ 0.5865, -0.3689],
        [ 1.5888, -0.8851],
        [ 0.0220,  0.4925],
        [ 0.2183,  0.2284],
        [-0.7125,  1.1659],
        [-0.8214,  1.1125],
        [-1.5483,  1.6601],
        [-0.3690,  0.4660]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[ 0.6315, -0.1672],
        [-0.2632,  0.5701],
        [-0.7606,  0.8071],
        [-0.6759,  0.8296],
        [ 0.5177, -0.2782],
        [-0.3465,  0.5850],
        [ 0.6924, -0.3534],
        [-1.0656,  1.2688],
        [-0.2954,  0.5612],
        [-0.3581,  0.6719],
        [ 1.2011, -0.7967],
        [-0.5670,  0.6853]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-1.4507,  1.6519],
        [ 0.9130, -0.4895],
        [ 1.0946, -0.7731],
        [-0.8934,  1.0620],
        [ 0.6862, -0.6074],
        [ 0.5505, -0.1719],
        [-0.9506,  1.2125],
        [-2.2094,  2.3006],
        [ 0.6842, -0.2158],
        [-1.5070,  1.5104],
        [ 0.7472, -0.4445],
        [ 0.0793,  0.2773]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.9179,  1.2521],
        [-0.0311,  0.2022],
        [-0.9239,  1.2958],
        [-0.1557,  0.3840],
        [ 0.0652,  0.3899],
        [-0.2952,  0.5335],
        [ 0.3089,  0.0332],
        [ 1.0436, -0.5872],
        [ 0.1894,  0.0119],
        [ 0.2914, -0.0592],
        [ 0.5574, -0.3443],
        [-0.4480,  0.6913]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-1.4328,  1.6468],
        [-1.3572,  1.4837],
        [-0.3656,  0.6820],
        [-0.1714,  0.5913],
        [-0.1842,  0.3898],
        [-0.0154,  0.4280],
        [-0.3705,  0.5173],
        [ 0.8900, -0.3370],
        [-1.0700,  1.3423],
        [-0.1661,  0.4765],
        [ 1.7264, -1.3349],
        [ 0.1922, -0.0145]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 1.3162, -1.0210],
        [-0.4375,  0.6296],
        [-0.9182,  1.0429],
        [-1.4862,  1.5461],
        [-1.4860,  1.5428],
        [-1.4948,  1.5416],
        [ 0.5455, -0.0890],
        [-0.8028,  1.0269],
        [ 1.4546, -1.0039],
        [-1.3424,  1.4853],
        [-1.4597,  1.4048],
        [ 0.2722, -0.0987]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 7.8531e-01, -6.4240e-01],
        [-4.3646e-04,  3.1870e-01],
        [-2.8735e-01,  6.1865e-01],
        [-3.2678e-01,  5.7514e-01],
        [-1.0377e+00,  1.3263e+00],
        [ 2.0224e-01,  1.8620e-01],
        [ 4.0906e-01, -9.4870e-02],
        [-6.7100e-01,  8.4703e-01],
        [-6.4768e-01,  6.8761e-01],
        [ 6.5654e-01, -3.3571e-01],
        [-7.9103e-01,  9.2454e-01],
        [-2.1595e+00,  2.2493e+00]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[-0.3439,  0.5114],
        [-0.3574,  0.6230],
        [-0.4520,  0.5825],
        [-0.2919,  0.6658],
        [-0.2201,  0.4264],
        [ 1.4474, -1.0302],
        [-0.9270,  1.0987],
        [-1.4003,  1.5997],
        [ 1.7123, -1.3316],
        [-0.4702,  0.7811],
        [-2.4114,  2.5458],
        [-0.2202,  0.4695]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-0.0767,  0.3384],
        [-1.0705,  1.5000],
        [-0.0208,  0.2837],
        [-0.0101,  0.2945],
        [-1.1197,  1.2487],
        [-0.4143,  0.6897],
        [-1.0995,  1.2183],
        [-1.9010,  2.0195],
        [ 0.5345, -0.1542],
        [-0.2555,  0.4968],
        [-0.8029,  0.9657],
        [ 0.8313, -0.2382]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-0.8023,  1.0314],
        [-1.1499,  1.0148],
        [-1.3660,  1.4535],
        [-1.5292,  1.8125],
        [ 1.0584, -0.7957],
        [-1.2833,  1.5128],
        [-0.4691,  0.5294],
        [-0.8328,  0.9180],
        [ 1.5590, -1.0844],
        [-0.4494,  0.4289],
        [ 0.7083, -0.4655],
        [ 0.0663,  0.0516]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-1.1751,  1.1110],
        [-0.0527,  0.2564],
        [-0.3513,  0.5888],
        [-0.1608,  0.4991],
        [-0.2484,  0.4247],
        [ 1.3622, -0.7883],
        [-0.5818,  0.9103],
        [-1.7414,  1.9966],
        [ 1.3896, -1.0031],
        [-2.0342,  2.0758],
        [-1.2054,  1.2723],
        [-0.5694,  0.7148]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-0.9672,  1.1011],
        [ 1.0876, -0.5895],
        [ 0.4577, -0.0925],
        [-0.0905,  0.3748],
        [ 0.9165, -0.5841],
        [-0.0064, -0.0073],
        [ 0.5520, -0.1416],
        [ 0.1610,  0.0922],
        [-0.5397,  1.0059],
        [ 0.3542, -0.0933],
        [-0.0611,  0.1762],
        [ 1.0956, -0.7245]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[ 0.5526, -0.2247],
        [ 0.6559, -0.3300],
        [ 1.4229, -1.0719],
        [-0.4918,  0.7689],
        [-1.1474,  1.3185],
        [ 1.3535, -0.9389],
        [ 0.7934, -0.3815],
        [ 1.6090, -1.1948],
        [ 0.4585, -0.2805],
        [ 0.1060,  0.2035],
        [ 1.2457, -0.9426],
        [-1.4853,  1.4837]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-1.3314,  1.5561],
        [ 0.7437, -0.3780],
        [-0.6326,  0.6122],
        [ 1.3576, -1.0403],
        [ 0.6230, -0.2872],
        [ 1.8288, -1.5762],
        [-0.6174,  0.6968],
        [-2.4674,  2.6187],
        [ 0.9537, -0.5633],
        [-1.8343,  2.0232],
        [-0.3298,  0.7016],
        [-0.2635,  0.5475]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.5478,  0.7108],
        [-0.2502,  0.3942],
        [-0.5660,  1.0207],
        [-0.4159,  0.6426],
        [-0.6250,  0.9193],
        [ 0.3470,  0.0804],
        [ 1.0414, -0.5877],
        [-0.9943,  1.3075],
        [-0.5925,  0.7710],
        [ 0.4612, -0.0523],
        [-1.7377,  1.8717],
        [-1.4944,  1.5526]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-0.1261,  0.4620],
        [-1.3258,  1.6372],
        [-0.7393,  0.9878],
        [-0.8193,  0.9243],
        [ 1.1015, -0.9721],
        [-1.3200,  1.4507],
        [-1.4878,  1.3481],
        [ 0.9402, -0.4592],
        [-0.2238,  0.6437],
        [-0.0300,  0.1621],
        [ 1.1766, -0.8744],
        [-1.3136,  1.4538]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 0.1785,  0.1140],
        [-0.7292,  1.0709],
        [-0.7006,  0.9934],
        [-1.9967,  2.1386],
        [-1.3896,  1.7697],
        [-1.4472,  1.6114],
        [-0.2269,  0.4522],
        [-1.6050,  1.5616],
        [ 0.3929, -0.1448],
        [-1.8659,  1.9280],
        [-1.1421,  1.4438],
        [-1.0707,  1.1692]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[-0.1410,  0.4801],
        [-0.6051,  0.8832],
        [-0.2952,  0.4936],
        [-0.4303,  0.7990],
        [-0.3767,  0.6527],
        [-0.3066,  0.7477],
        [-0.2999,  0.3281],
        [-0.7233,  0.6547],
        [-0.9007,  0.8568],
        [ 0.0737, -0.0796],
        [-1.0993,  1.2429],
        [-2.1672,  2.1685]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[ 0.4272,  0.0790],
        [-0.7301,  0.8110],
        [-0.2267,  0.6143],
        [-0.6738,  0.9215],
        [-0.1275,  0.2193],
        [-1.0862,  1.0475],
        [-1.3309,  1.4717],
        [-1.0298,  1.1971],
        [-0.4337,  0.4432],
        [-0.4431,  0.8205],
        [-1.1202,  1.3153],
        [-1.9590,  2.0494]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-0.3532,  0.4864],
        [-0.7745,  0.9884],
        [ 0.0156,  0.3350],
        [-1.0255,  1.0587],
        [-1.0737,  1.3156],
        [-1.2916,  1.4479],
        [-1.8083,  1.7211],
        [-1.1019,  1.2163],
        [ 0.3489, -0.1027],
        [-1.8489,  1.8965],
        [ 1.6540, -1.1290],
        [-0.6108,  0.6150]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-0.6747,  0.8756],
        [-1.7617,  1.9691],
        [-1.4219,  1.6930],
        [-0.5567,  0.7385],
        [ 1.2644, -0.8084],
        [-1.7792,  1.8269],
        [-1.2009,  1.3634],
        [-0.9881,  1.1215],
        [ 1.4536, -1.2859],
        [-0.1059,  0.5821],
        [ 0.0245,  0.3810],
        [-0.2544,  0.3232]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-1.0701,  1.2346],
        [ 0.2357, -0.1058],
        [-1.4015,  1.3717],
        [-1.2864,  1.3947],
        [-0.8135,  0.8471],
        [ 0.2450, -0.1351],
        [ 1.0460, -0.6822],
        [-1.9100,  1.9759],
        [-0.2774,  0.3294],
        [-0.5021,  0.9100],
        [-1.2171,  1.1231],
        [-1.5190,  1.6930]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-0.7453,  1.0335],
        [-0.4454,  0.6311],
        [-0.4598,  0.7207],
        [-1.0604,  1.2523],
        [ 1.7724, -1.4665],
        [-0.4004,  0.7941],
        [-0.2871,  0.5007],
        [-0.8221,  0.8520],
        [ 0.3249,  0.0103],
        [-0.7816,  1.1109],
        [-0.0807,  0.3990],
        [ 0.0531,  0.0790]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[ 0.9565, -0.5923],
        [ 0.3162, -0.0450],
        [ 0.3056, -0.0194],
        [ 0.2828, -0.0874],
        [ 0.5741, -0.2790],
        [ 1.5798, -1.1681],
        [-0.6265,  0.9485],
        [ 0.7079, -0.3139],
        [ 0.2897, -0.2626],
        [-0.4575,  0.6286],
        [ 0.5496, -0.2548],
        [-1.7180,  1.7733]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[ 0.4559, -0.0821],
        [ 0.5081, -0.0801],
        [ 1.1432, -0.7086],
        [ 2.2263, -1.9706],
        [ 1.6812, -1.1779],
        [ 1.1598, -0.7033],
        [ 0.0742,  0.3503],
        [-2.1337,  2.0886],
        [ 0.0599,  0.0288],
        [-0.5392,  0.5929],
        [ 0.3907, -0.1229],
        [-1.3795,  1.5526]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[ 0.0916,  0.0736],
        [-1.8777,  1.7691],
        [ 0.4987, -0.0928],
        [-0.9270,  1.1099],
        [ 0.2140,  0.1004],
        [-1.3113,  1.4926],
        [ 2.0460, -1.6369],
        [-0.1179,  0.2823],
        [-0.1527,  0.1391],
        [-0.2729,  0.6359],
        [-0.8855,  1.1146],
        [-0.4585,  0.7157]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-0.3368,  0.6421],
        [-0.6221,  0.8236],
        [-0.5047,  0.7221],
        [ 0.5831, -0.4263],
        [ 0.4419, -0.1970],
        [-1.8746,  2.1256],
        [ 1.8498, -1.3705],
        [ 0.0197,  0.0632],
        [ 0.5216, -0.2839],
        [-0.7636,  1.1076],
        [ 0.1414,  0.0808],
        [ 0.9111, -0.4184]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 1.0895, -0.7475],
        [ 1.0354, -0.6624],
        [-1.4072,  1.4921],
        [-2.3799,  2.4048],
        [-0.6807,  0.7469],
        [-1.8524,  1.7413],
        [-0.9396,  1.0946],
        [ 0.3522, -0.1662],
        [ 0.4688, -0.1550],
        [ 0.2895, -0.0238],
        [-0.6333,  0.8375],
        [ 0.1381,  0.0579]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 0.4218,  0.2079],
        [-0.1605,  0.2315],
        [ 1.4385, -0.9873],
        [-1.3482,  1.6248],
        [-0.1632,  0.2066],
        [ 0.1963,  0.2007],
        [-0.7647,  0.8412],
        [-1.1197,  1.2887],
        [-1.3303,  1.5774],
        [-0.4051,  0.6521],
        [-1.7103,  1.7245],
        [-2.1375,  2.4233]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[ 0.6009, -0.2810],
        [-0.4383,  0.7235],
        [-0.6806,  0.9222],
        [-0.3235,  0.4989],
        [-0.8965,  1.1147],
        [-0.2142,  0.2455],
        [-1.6846,  1.7820],
        [-1.4052,  1.5674],
        [ 0.2984, -0.0048],
        [ 0.6576, -0.6026],
        [-2.0526,  2.1966],
        [-0.8446,  1.0368]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[ 0.8143, -0.5568],
        [-0.4975,  0.8269],
        [-0.8011,  1.0532],
        [-0.3439,  0.7177],
        [-1.2643,  1.3609],
        [-0.1337,  0.3459],
        [-0.8492,  0.9638],
        [-2.3662,  2.3802],
        [ 1.3440, -0.9971],
        [-1.1241,  1.2961],
        [ 1.5273, -1.1372],
        [ 0.4837, -0.3993]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-1.0306,  1.3657],
        [-0.9306,  1.1194],
        [-0.1716,  0.4881],
        [-0.6989,  1.0101],
        [-0.7732,  0.9005],
        [-1.2531,  1.2914],
        [-2.0508,  2.0862],
        [-1.5827,  1.6791],
        [ 1.7461, -1.4839],
        [-0.5410,  0.8158],
        [-0.2197,  0.4203],
        [ 1.5294, -0.9607]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-0.2680,  0.6566],
        [ 1.4358, -0.8220],
        [-0.8087,  1.1190],
        [-1.8348,  2.1133],
        [-1.4568,  1.8379],
        [ 0.7762, -0.5214],
        [ 1.3102, -0.8413],
        [-2.0788,  2.1279],
        [-0.4411,  0.6332],
        [-1.1878,  1.4231],
        [-0.1977,  0.3344],
        [-0.6201,  0.6934]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-0.2690,  0.3805],
        [ 0.0994,  0.1058],
        [-1.3024,  1.5063],
        [ 0.2780,  0.0599],
        [-0.4166,  0.5197],
        [ 1.2321, -0.8324],
        [-0.9315,  0.9227],
        [-0.0800,  0.3684],
        [ 0.3607,  0.1606],
        [-0.0437,  0.3037],
        [-1.2048,  1.4301],
        [-0.2935,  0.5081]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-1.0768,  1.4843],
        [-0.8561,  1.1420],
        [ 0.1974,  0.1680],
        [ 0.8381, -0.5414],
        [ 0.0216,  0.4491],
        [ 1.3271, -0.9368],
        [ 1.3106, -0.8474],
        [-0.1827,  0.4122],
        [ 0.6714, -0.3184],
        [-0.8802,  1.0517],
        [-0.7525,  0.9587],
        [-0.9319,  1.0235]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-0.7434,  0.8036],
        [-0.1756,  0.4217],
        [ 1.7275, -1.3383],
        [-0.5047,  0.8393],
        [ 2.0407, -1.8120],
        [ 1.8053, -1.1501],
        [-0.3889,  0.3801],
        [-1.6010,  1.6014],
        [ 2.6062, -2.0903],
        [-0.2637,  0.6112],
        [ 0.9286, -0.6935],
        [-0.5646,  0.5639]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.1001,  0.2882],
        [-0.4104,  0.5847],
        [-0.0139,  0.3296],
        [ 0.3976, -0.1666],
        [-0.1341,  0.3815],
        [-0.2573,  0.6577],
        [ 0.5102, -0.2464],
        [ 0.7277, -0.4360],
        [-0.4249,  0.7417],
        [ 0.4609, -0.0874],
        [-0.4298,  0.6033],
        [-0.5097,  0.7529]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-1.0603,  1.3357],
        [ 1.0724, -0.5931],
        [-0.1857,  0.3851],
        [ 0.6560, -0.2692],
        [-0.0786,  0.2447],
        [-0.3044,  0.6066],
        [-0.6981,  0.8781],
        [-0.2683,  0.5444],
        [ 0.7066, -0.3867],
        [-0.2352,  0.3138],
        [ 1.2152, -0.8577],
        [ 0.6637, -0.3617]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 0.1344,  0.1755],
        [ 1.1163, -0.8895],
        [-1.9625,  1.9167],
        [-1.6907,  2.0461],
        [ 0.9853, -0.9401],
        [ 0.2695, -0.0363],
        [-0.2206,  0.5558],
        [-1.1116,  1.2589],
        [-0.2078,  0.6180],
        [-0.1084,  0.3406],
        [-0.3299,  0.5068],
        [-0.9935,  1.0887]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 1.7241, -1.1351],
        [ 0.2042,  0.0542],
        [-0.4763,  0.3943],
        [-0.4005,  0.5851],
        [-0.6645,  1.0873],
        [ 0.4007, -0.0472],
        [ 1.4794, -1.0796],
        [-0.5923,  0.6204],
        [-1.3308,  1.3119],
        [ 0.7086, -0.3606],
        [-1.5291,  1.5944],
        [-1.9028,  2.1972]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[ 0.4673, -0.3131],
        [-1.4137,  1.4122],
        [-1.2211,  1.4717],
        [-1.3400,  1.4810],
        [-0.7158,  1.0321],
        [-0.4773,  0.6204],
        [-1.1364,  1.3630],
        [ 0.2858, -0.0018],
        [ 1.3974, -0.8953],
        [-0.0072,  0.2897],
        [-0.1469,  0.3296],
        [-1.4851,  1.5536]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[ 0.1467,  0.1740],
        [ 0.1376,  0.2169],
        [-1.1676,  1.3591],
        [-1.3528,  1.3362],
        [ 0.1406,  0.1834],
        [-0.6171,  0.6923],
        [-1.8508,  2.0472],
        [-1.7706,  1.9425],
        [ 2.3194, -1.9749],
        [-1.6774,  1.9033],
        [ 1.3012, -1.0118],
        [ 1.8388, -1.3805]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[ 0.5401, -0.2283],
        [-0.3016,  0.6701],
        [-0.5025,  0.8074],
        [ 0.4756, -0.4116],
        [ 0.8153, -0.4760],
        [-0.7271,  0.9228],
        [-1.1548,  1.3569],
        [-0.4010,  0.4932],
        [ 1.1656, -0.8925],
        [ 1.3309, -0.9343],
        [-0.1155,  0.4436],
        [ 1.7288, -1.6170]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-0.3447,  0.3129],
        [ 0.2384,  0.2372],
        [-0.2701,  0.5968],
        [-0.2387,  0.5503],
        [-1.5828,  1.8001],
        [ 1.7067, -1.3166],
        [-0.0313,  0.2936],
        [-2.0639,  2.0212],
        [ 0.9512, -0.6427],
        [-0.2514,  0.3279],
        [ 1.1896, -0.9491],
        [-1.0735,  1.3022]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-1.0742,  1.2456],
        [ 1.1216, -0.6923],
        [-1.0287,  1.3121],
        [-0.9056,  1.0622],
        [ 0.8275, -0.4578],
        [-0.0722,  0.5024],
        [-0.5062,  0.6106],
        [-0.8214,  0.9120],
        [-0.3463,  0.9753],
        [-1.4716,  1.8042],
        [ 0.8093, -0.4436],
        [ 0.6196, -0.2235]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-0.1446,  0.3246],
        [-0.6186,  0.9004],
        [-0.1514,  0.4530],
        [-1.8340,  1.8659],
        [-1.0705,  1.2911],
        [-0.1863,  0.2816],
        [-0.9962,  1.0959],
        [ 0.7748, -0.4337],
        [-0.5548,  0.6610],
        [-0.8162,  0.8209],
        [-1.1274,  1.1876],
        [-2.4882,  2.5546]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-1.0804,  1.4691],
        [ 1.4929, -0.9726],
        [ 1.1308, -0.7651],
        [-1.3763,  1.4390],
        [ 1.3862, -1.0454],
        [ 0.1279,  0.2124],
        [ 0.3327,  0.1574],
        [-1.9313,  2.1533],
        [ 0.5562, -0.1614],
        [-2.2955,  2.5866],
        [-0.6448,  0.7927],
        [-0.8082,  1.1387]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-1.3892,  1.5636],
        [-2.3116,  2.4430],
        [-1.9971,  2.1458],
        [-1.5365,  1.7570],
        [-1.0061,  1.3495],
        [-1.5712,  1.6940],
        [ 0.1129,  0.4023],
        [ 0.3189,  0.0485],
        [-0.4367,  0.6941],
        [-0.3570,  0.3693],
        [-0.7341,  0.7862],
        [-1.4318,  1.9213]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-0.8682,  1.0942],
        [-1.7714,  1.9154],
        [-0.1702,  0.3936],
        [-1.4479,  1.5416],
        [-1.4307,  1.7014],
        [-1.8372,  2.0277],
        [-0.8409,  1.0904],
        [-0.1324,  0.5704],
        [ 0.9089, -0.3908],
        [-0.2550,  0.4142],
        [ 0.7227, -0.5804],
        [-1.0578,  1.1933]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 8.8433e-01, -4.2399e-01],
        [ 7.4254e-01, -2.9802e-01],
        [-1.5145e+00,  1.6617e+00],
        [-1.3514e+00,  1.4871e+00],
        [-7.2821e-01,  7.1512e-01],
        [-9.2706e-01,  1.1830e+00],
        [-9.4434e-02,  3.2139e-01],
        [-8.0477e-01,  8.8201e-01],
        [ 1.5031e-01, -4.5262e-05],
        [-2.1120e-01,  2.0492e-01],
        [-9.2164e-01,  1.1359e+00],
        [ 6.2260e-01, -3.9552e-01]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[-0.2847,  0.6954],
        [-0.5242,  0.8415],
        [-1.4977,  1.7104],
        [-0.4129,  0.8595],
        [-1.0557,  1.1491],
        [-1.6935,  1.8702],
        [-0.2246,  0.2406],
        [-0.9800,  1.2556],
        [-1.0190,  1.0942],
        [-0.2950,  0.6664],
        [-1.5671,  1.7533],
        [-2.4529,  2.5442]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[-0.8726,  0.9698],
        [-1.6390,  1.6169],
        [-0.0866,  0.3066],
        [-2.2787,  2.2323],
        [-0.0338,  0.5050],
        [-0.3556,  0.5837],
        [-1.9104,  1.9426],
        [-1.6963,  1.8901],
        [ 1.1941, -0.8926],
        [-0.5275,  0.6964],
        [-2.2499,  2.1863],
        [-2.2295,  2.2527]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-1.8462,  1.8070],
        [-0.8227,  1.0910],
        [-2.2285,  2.2685],
        [-0.9195,  1.2967],
        [-1.2069,  1.5827],
        [ 0.4869, -0.1100],
        [-0.7555,  0.9210],
        [-2.4007,  2.3897],
        [ 1.7108, -1.4077],
        [-0.2122,  0.6617],
        [-1.0547,  1.3827],
        [-0.8109,  0.7905]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-0.4409,  0.7096],
        [ 0.2980,  0.1216],
        [-0.1374,  0.3261],
        [ 0.9862, -0.7256],
        [ 0.3380,  0.0427],
        [-1.9014,  2.0700],
        [-0.7089,  0.8925],
        [-0.7122,  0.9077],
        [ 0.0426,  0.1188],
        [-0.3246,  0.4111],
        [-1.6584,  1.7790],
        [-0.0186,  0.1400]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-0.9612,  1.1757],
        [-0.8816,  1.1205],
        [-0.2821,  0.4859],
        [-1.7356,  1.8330],
        [-1.1054,  1.3028],
        [ 0.1122,  0.1981],
        [-0.9400,  1.1668],
        [-2.1212,  2.2984],
        [ 0.8801, -0.5370],
        [-1.4390,  1.7084],
        [-0.0035,  0.5205],
        [-2.1123,  2.2314]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-0.9877,  1.2433],
        [-0.0093,  0.0565],
        [-1.7197,  1.7797],
        [-0.6685,  0.8548],
        [ 0.1518,  0.2938],
        [ 1.8147, -1.4824],
        [-1.6095,  1.5209],
        [-0.4677,  0.8383],
        [-1.1370,  1.3320],
        [-0.7308,  1.0218],
        [ 0.6873, -0.1644],
        [-0.2677,  0.5454]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-0.7419,  1.1167],
        [-1.0818,  1.4738],
        [ 1.8633, -1.4148],
        [ 0.6301, -0.2841],
        [-0.6634,  0.9547],
        [-0.9642,  1.1216],
        [ 1.7854, -1.2816],
        [-1.2997,  1.4893],
        [-0.3420,  0.5650],
        [-1.3501,  1.6257],
        [ 0.9816, -0.5478],
        [-1.3078,  1.2745]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-0.5566,  0.8060],
        [-0.5438,  0.9040],
        [ 0.3423, -0.0169],
        [ 0.7331, -0.2770],
        [ 0.8976, -0.4381],
        [ 0.7410, -0.2623],
        [-0.4385,  0.7491],
        [-1.2731,  1.5232],
        [-0.9182,  1.0852],
        [-0.7781,  0.9546],
        [-1.1861,  1.2609],
        [ 0.2233,  0.0399]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.6840,  1.1153],
        [-2.4319,  2.4755],
        [-1.3032,  1.4930],
        [ 0.3849, -0.0855],
        [ 0.3723, -0.0706],
        [-1.6538,  1.9336],
        [ 0.0355,  0.3765],
        [ 0.1299,  0.1682],
        [-0.1963,  0.3500],
        [ 0.9667, -0.6733],
        [ 0.5924, -0.0677],
        [-0.3567,  0.8049]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-1.1713,  1.6138],
        [ 0.2587, -0.0430],
        [-1.6828,  2.0763],
        [-0.5127,  0.8338],
        [ 0.0445,  0.1442],
        [-1.6809,  1.7396],
        [ 1.0684, -0.8362],
        [ 1.1972, -0.7935],
        [ 0.3828,  0.0606],
        [-0.4487,  0.6967],
        [ 0.9321, -0.5486],
        [ 0.7281, -0.1339]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 0.7430, -0.1524],
        [ 0.4864, -0.0268],
        [-0.5476,  1.0299],
        [-1.6138,  1.7190],
        [-1.0101,  1.2322],
        [-1.4360,  1.4381],
        [ 1.5135, -1.1523],
        [-0.9898,  1.0710],
        [ 0.1564, -0.0798],
        [-0.3411,  0.6755],
        [-1.0158,  1.1895],
        [ 0.0255,  0.1532]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 1.8368, -1.5064],
        [-1.0163,  1.2085],
        [-0.1120,  0.4662],
        [-0.9108,  1.0871],
        [-0.9469,  1.1894],
        [ 0.2422,  0.0857],
        [-0.5100,  0.8107],
        [-0.3842,  0.5874],
        [-2.6161,  2.6383],
        [ 0.4411, -0.0696],
        [-1.2178,  1.4420],
        [-2.3817,  2.4079]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[-4.6516e-01,  7.9409e-01],
        [-4.6377e-01,  6.8038e-01],
        [-1.4148e+00,  1.7673e+00],
        [-2.6024e+00,  2.6523e+00],
        [ 2.3615e-03,  4.3900e-01],
        [ 3.4144e-01,  3.3610e-04],
        [-2.0815e+00,  2.0839e+00],
        [-9.9032e-01,  1.3322e+00],
        [ 2.3119e+00, -1.8172e+00],
        [ 9.3993e-02,  1.4442e-01],
        [-1.8530e+00,  2.1653e+00],
        [-1.5179e+00,  1.7350e+00]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[ 0.6762, -0.1828],
        [-1.2558,  1.4883],
        [-1.2747,  1.3955],
        [ 1.0800, -0.7033],
        [-0.4234,  0.4302],
        [ 0.6654, -0.2461],
        [-1.1422,  1.4525],
        [-1.5819,  1.6745],
        [ 2.4280, -1.9169],
        [-1.6078,  1.9662],
        [ 1.9095, -1.4557],
        [ 2.2180, -1.8363]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-0.1643,  0.4647],
        [-0.6872,  0.9939],
        [ 0.3503,  0.0196],
        [-0.3757,  0.5712],
        [-0.2989,  0.7754],
        [-1.0263,  1.3259],
        [ 0.8379, -0.4953],
        [-1.4601,  1.5347],
        [ 0.5659,  0.0169],
        [ 0.3448, -0.1441],
        [-0.4294,  0.7408],
        [ 1.6494, -1.2048]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-0.6331,  1.0114],
        [-0.6867,  0.8381],
        [ 0.3052, -0.0453],
        [-1.5928,  1.7311],
        [-2.3158,  2.2725],
        [ 2.0136, -1.5630],
        [ 0.0744,  0.1795],
        [-0.7270,  0.9596],
        [ 1.4293, -0.9184],
        [-1.3926,  1.5353],
        [-0.7124,  0.8755],
        [-2.0098,  2.0640]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-1.5069,  1.4214],
        [ 0.9611, -0.6042],
        [-1.9147,  2.1105],
        [-0.1880,  0.4874],
        [ 0.5376, -0.3024],
        [ 1.3000, -0.9134],
        [-0.8051,  1.3475],
        [ 0.5850, -0.1532],
        [ 1.2343, -0.9077],
        [-0.1195,  0.5052],
        [ 1.0703, -0.7381],
        [-1.9568,  2.1575]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[ 1.3422, -0.8211],
        [ 0.3889, -0.0935],
        [ 1.8954, -1.5757],
        [-0.4247,  0.8674],
        [-0.4515,  0.6612],
        [-0.3042,  0.6247],
        [ 1.2221, -0.7310],
        [ 1.5366, -0.9974],
        [-1.3262,  1.3442],
        [ 0.4266,  0.0438],
        [-1.0819,  1.3974],
        [-1.3466,  1.5787]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-1.4020,  1.5085],
        [ 1.8214, -1.2764],
        [ 2.2549, -1.9405],
        [ 0.4579, -0.3260],
        [ 1.6545, -1.3620],
        [ 1.8921, -1.6296],
        [ 1.9377, -1.4466],
        [-0.7977,  0.9244],
        [ 1.2727, -0.7639],
        [-1.8300,  2.0592],
        [-0.5721,  0.8236],
        [ 1.3910, -0.9152]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.2714,  0.5779],
        [-2.1271,  2.2496],
        [-0.9859,  1.1051],
        [-0.0236,  0.3173],
        [ 0.2973,  0.1805],
        [-1.3699,  1.5278],
        [ 0.0532,  0.4183],
        [ 1.0056, -0.6452],
        [ 2.1454, -1.5838],
        [ 0.8089, -0.4032],
        [-0.0920,  0.2548],
        [ 1.3408, -0.9113]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-0.8018,  1.1408],
        [ 0.3268, -0.1317],
        [ 0.7411, -0.2214],
        [ 2.0647, -1.5951],
        [ 0.5971, -0.2849],
        [-1.0336,  1.2594],
        [-0.1480,  0.3616],
        [-0.1594,  0.5868],
        [ 1.6592, -1.4399],
        [-0.4347,  0.5431],
        [-0.0939,  0.2907],
        [ 1.1061, -0.7102]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[-1.5412,  1.9103],
        [ 1.6748, -1.3135],
        [ 0.4763, -0.1866],
        [-1.2634,  1.4368],
        [ 1.0523, -0.5993],
        [-1.4989,  1.6350],
        [-1.1962,  1.2382],
        [-1.8871,  1.9320],
        [-1.8162,  2.0064],
        [-0.7182,  1.0677],
        [-2.4496,  2.5374],
        [ 0.1871,  0.3655]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[-0.1548,  0.3394],
        [ 0.7706, -0.4927],
        [ 0.3048,  0.0531],
        [ 0.8010, -0.2516],
        [ 0.6671, -0.3183],
        [-1.0208,  1.3003],
        [ 0.6810, -0.5942],
        [-0.2528,  0.2399],
        [-1.8039,  1.8822],
        [ 1.5305, -1.2832],
        [-1.7862,  2.1175],
        [-2.1570,  2.2728]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[ 1.5641, -1.2922],
        [-0.3692,  0.7480],
        [ 0.5768, -0.3392],
        [-2.2481,  2.3168],
        [ 1.4417, -0.9324],
        [-0.0111,  0.2604],
        [-0.5900,  0.9901],
        [-0.8834,  1.1762],
        [ 0.5411, -0.4544],
        [-1.3095,  1.3897],
        [-0.0282,  0.3262],
        [-0.1682,  0.3485]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-1.6386,  1.8768],
        [-2.8007,  2.8355],
        [-2.9420,  2.8134],
        [-2.0620,  2.0432],
        [-2.4465,  2.4073],
        [-2.8381,  2.8130],
        [-2.3833,  2.4125],
        [-2.6524,  2.6179],
        [-0.9336,  1.0888],
        [-1.6562,  1.7363],
        [-1.7094,  1.9075],
        [-0.6185,  0.8312]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-2.6741,  2.7048],
        [-3.0173,  2.9765],
        [-1.2679,  1.4809],
        [-3.0826,  3.1103],
        [-1.2876,  1.5069],
        [-2.9222,  2.8484],
        [-2.5336,  2.7106],
        [-1.9401,  1.9485],
        [-3.1610,  3.2282],
        [-2.5004,  2.7208],
        [-0.7341,  0.9020],
        [-2.3790,  2.5255]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-2.3028,  2.4182],
        [-2.2382,  2.4818],
        [-2.1119,  2.3343],
        [-2.4903,  2.5426],
        [-2.7442,  2.8378],
        [-2.8543,  2.9134],
        [-1.7149,  1.9167],
        [-1.3644,  1.6502],
        [-0.9032,  1.1674],
        [-2.2670,  2.3347],
        [-2.5605,  2.8207],
        [-2.4231,  2.7053]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-1.5639,  1.8556],
        [-1.5595,  1.5428],
        [-2.6369,  2.5323],
        [-2.7605,  2.7746],
        [-2.0963,  2.1692],
        [-0.8873,  1.1521],
        [-1.3566,  1.6496],
        [-2.2567,  2.3874],
        [-0.7700,  1.3293],
        [-1.3724,  1.5241],
        [-1.8618,  1.9774],
        [-2.0152,  2.0019]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-1.8860,  1.9794],
        [-1.8075,  1.8901],
        [-1.3444,  1.4764],
        [-1.2975,  1.3190],
        [-2.2612,  2.4381],
        [-2.5842,  2.6781],
        [-1.2435,  1.4148],
        [-1.4102,  1.5787],
        [-0.2389,  0.3468],
        [-1.5583,  1.8603],
        [-2.3560,  2.4696],
        [-2.6323,  2.6601]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-2.3600,  2.3982],
        [-1.9582,  2.1443],
        [-1.3491,  1.5229],
        [-1.2506,  1.5319],
        [-0.3269,  0.5161],
        [-1.3959,  1.4708],
        [-1.2747,  1.3206],
        [-2.0095,  2.1066],
        [-0.8445,  1.1394],
        [-2.3932,  2.4248],
        [-0.9693,  1.2534],
        [-0.6530,  1.0570]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.7261,  0.8106],
        [-2.2678,  2.4245],
        [-2.0449,  2.2478],
        [-0.4692,  0.7224],
        [-1.3615,  1.5220],
        [-2.3559,  2.6223],
        [-0.5446,  0.7571],
        [-0.2525,  0.5759],
        [-1.8158,  2.1441],
        [-1.5634,  1.7403],
        [-1.8595,  2.1248],
        [-0.7485,  0.9293]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-1.8767,  1.9062],
        [-1.4685,  1.6976],
        [-1.6322,  1.9027],
        [-0.6460,  1.0590],
        [-2.1320,  2.1052],
        [-1.6206,  1.8992],
        [-2.4502,  2.4390],
        [-1.6903,  1.6303],
        [-1.1913,  1.1816],
        [-1.4423,  1.6586],
        [-1.3971,  1.4430],
        [-1.3324,  1.5576]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[-0.2311,  0.4613],
        [-0.7182,  1.0889],
        [-1.3364,  1.5039],
        [-1.2883,  1.3938],
        [-1.4963,  1.9008],
        [-1.7853,  1.8036],
        [-1.5784,  1.7191],
        [-1.6230,  1.9142],
        [-1.4210,  1.4110],
        [-1.7601,  1.8124],
        [-2.1458,  2.2571],
        [-1.0602,  1.4449]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[-0.4078,  0.6941],
        [-1.6406,  1.7369],
        [-1.7778,  1.7601],
        [-2.1183,  2.5191],
        [-2.4030,  2.3378],
        [-2.3658,  2.5867],
        [-1.8113,  1.8524],
        [-1.5027,  1.5547],
        [-2.1115,  2.2646],
        [-0.8792,  1.0117],
        [-1.1149,  1.2446],
        [-2.2215,  2.5485]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[-1.9753,  2.2152],
        [-2.0073,  1.9440],
        [-2.4396,  2.3899],
        [-2.2731,  2.4068],
        [-1.3794,  1.4788],
        [-1.5045,  1.5909],
        [-1.3152,  1.5308],
        [-0.9950,  1.2138],
        [-1.0966,  1.2445],
        [-1.5983,  1.7481],
        [-1.4730,  1.7496],
        [-2.0268,  2.3004]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-2.0937,  2.2349],
        [-1.8722,  2.1676],
        [-2.1361,  2.0875],
        [-2.5259,  2.5700],
        [-1.9168,  2.0029],
        [-1.7149,  2.2236],
        [-2.1734,  2.2078],
        [-1.4515,  1.7089],
        [ 0.4359, -0.1726],
        [-1.6025,  1.7830],
        [-0.6858,  0.8790],
        [ 0.1752,  0.1534]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-1.7793,  1.7784],
        [-0.8362,  1.2543],
        [ 0.4254, -0.1750],
        [-1.8564,  2.0039],
        [-0.9501,  1.4459],
        [-1.6046,  1.6311],
        [-1.4222,  1.6711],
        [-1.2084,  1.4796],
        [-1.9610,  2.1169],
        [-0.1876,  0.4698],
        [ 0.0843,  0.1390],
        [-1.8293,  1.8516]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-1.3134,  1.2444],
        [-1.0943,  1.3040],
        [-1.9685,  1.9355],
        [-2.6812,  2.5090],
        [-1.2682,  1.3373],
        [-1.2568,  1.3790],
        [-1.4256,  1.5673],
        [-1.0121,  1.3275],
        [-0.8530,  0.8114],
        [-2.4297,  2.5516],
        [-1.1966,  1.4155],
        [-1.8758,  2.2148]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-1.7187,  2.1210],
        [-1.5911,  1.6081],
        [-2.3867,  2.4214],
        [-1.2980,  1.4679],
        [-1.3066,  1.3282],
        [-0.4733,  0.5207],
        [-2.0732,  2.0904],
        [-1.3282,  1.5265],
        [-0.9916,  1.1952],
        [-1.3915,  1.4958],
        [-2.1000,  2.3406],
        [-1.2217,  1.2936]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-0.9545,  1.0132],
        [-1.6844,  1.7834],
        [-1.3881,  1.5143],
        [-1.3599,  1.4570],
        [-1.1971,  1.4680],
        [-1.4000,  1.6198],
        [-1.6472,  1.7909],
        [-1.2429,  1.1806],
        [-1.9777,  2.1550],
        [-1.8711,  2.1214],
        [-2.5480,  2.6193],
        [-2.3936,  2.4169]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-2.0869,  2.0350],
        [-1.2408,  1.4168],
        [-0.8407,  1.1216],
        [-1.2534,  1.4407],
        [-0.3356,  0.3121],
        [-1.2674,  1.3554],
        [-0.6560,  0.9984],
        [-1.4901,  1.7852],
        [-0.6514,  0.7804],
        [-1.8871,  2.0137],
        [-1.6566,  1.8591],
        [-1.2465,  1.4178]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-1.2167,  1.5582],
        [-2.1033,  2.3047],
        [-2.1914,  2.3577],
        [-1.4188,  1.7474],
        [-1.5578,  1.8525],
        [-2.3118,  2.3789],
        [-0.4869,  0.8201],
        [ 0.0383,  0.3934],
        [-1.1760,  1.3564],
        [-1.6574,  1.7074],
        [-1.7749,  1.9180],
        [-1.3173,  1.6253]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-1.1002,  1.1649],
        [-1.8443,  2.0687],
        [-2.0016,  1.9976],
        [ 0.1310,  0.0955],
        [-2.4227,  2.4856],
        [-1.2630,  1.2894],
        [-2.3377,  2.4153],
        [-1.8072,  1.9956],
        [ 0.0432,  0.2202],
        [-0.3355,  0.5272],
        [-1.5128,  1.7806],
        [-0.8488,  1.0782]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 0.4448,  0.0306],
        [-0.9992,  1.1914],
        [-1.3162,  1.5114],
        [-1.0890,  1.2270],
        [-0.7933,  1.1955],
        [-1.5662,  1.7878],
        [-2.2305,  2.3121],
        [-1.3323,  1.2922],
        [-1.9487,  1.9791],
        [-0.8229,  1.0286],
        [-1.2939,  1.4868],
        [-1.7340,  1.6279]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[-0.6715,  0.8365],
        [-1.5083,  1.7689],
        [-1.7099,  1.7345],
        [-2.2029,  2.2876],
        [-1.0287,  1.1453],
        [-1.6770,  1.8081],
        [-1.2302,  1.2805],
        [-1.6176,  1.7260],
        [-1.9690,  2.2015],
        [-1.2449,  1.2414],
        [-1.4372,  1.6992],
        [-2.1179,  2.2502]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[-1.1835,  1.3979],
        [-0.0884,  0.3315],
        [-0.9374,  1.0679],
        [-2.4905,  2.5705],
        [-1.5935,  1.7933],
        [-1.1602,  1.3977],
        [-2.1870,  2.3196],
        [-1.1585,  1.1893],
        [-1.2080,  1.2429],
        [-1.1867,  1.5943],
        [-1.8081,  2.0636],
        [-1.5121,  1.6415]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-0.8453,  1.1355],
        [-1.5097,  1.5698],
        [-1.8774,  1.9286],
        [-2.1572,  2.3271],
        [-1.3817,  1.4874],
        [-0.7555,  1.1851],
        [-1.5139,  1.5098],
        [-1.1704,  1.2579],
        [-0.0314,  0.5125],
        [-0.0112,  0.2518],
        [-1.3132,  1.3375],
        [ 0.7387, -0.4494]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-0.5888,  0.8459],
        [-1.9214,  1.9900],
        [-0.4277,  0.6131],
        [-0.7567,  0.9879],
        [-1.3430,  1.4757],
        [-1.2878,  1.5698],
        [-1.0417,  1.1951],
        [-1.8506,  1.9671],
        [-2.0965,  2.1230],
        [-1.0578,  1.3544],
        [-0.8468,  1.2433],
        [-0.3403,  0.3633]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-0.8223,  1.1314],
        [-1.3207,  1.5128],
        [-1.2095,  1.4669],
        [-1.9900,  2.2923],
        [-1.6609,  1.9793],
        [-0.6191,  0.9925],
        [-2.1792,  2.1413],
        [-2.0679,  2.1403],
        [-0.5975,  0.9194],
        [-2.6112,  2.5631],
        [-1.3433,  1.3759],
        [-0.9040,  1.0783]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-1.4112,  1.4786],
        [-1.1142,  1.4837],
        [-2.2154,  2.2705],
        [-1.8942,  1.9594],
        [-1.9194,  1.9081],
        [-0.4980,  0.7559],
        [-1.4430,  1.6310],
        [-0.6631,  0.9042],
        [-0.4324,  0.8515],
        [-0.4782,  0.5639],
        [-0.6815,  1.1338],
        [-0.3556,  0.4172]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-1.2013,  1.3265],
        [-2.5357,  2.6961],
        [-1.2288,  1.3989],
        [-0.3990,  0.5166],
        [-0.5920,  0.8194],
        [-1.8291,  1.9765],
        [-0.0617,  0.3680],
        [-0.6614,  0.8767],
        [-1.1912,  1.2903],
        [-1.4943,  1.7299],
        [-0.7494,  1.0841],
        [-1.5133,  1.7881]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-1.9468,  2.1307],
        [-1.0492,  1.1852],
        [ 0.0232,  0.0314],
        [-0.1105,  0.4920],
        [-0.0745,  0.3002],
        [-0.4987,  0.9248],
        [-1.4616,  1.7824],
        [-1.1453,  1.4202],
        [ 0.5400, -0.2127],
        [-1.6745,  1.8978],
        [-1.0388,  1.4525],
        [ 0.5217, -0.3603]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-1.2156,  1.2609],
        [-2.0349,  2.1006],
        [-1.2124,  1.3756],
        [ 0.3384, -0.0696],
        [-1.6137,  1.7053],
        [-1.2774,  1.4765],
        [ 0.5400, -0.2423],
        [ 0.5328, -0.0840],
        [-0.2475,  0.6034],
        [-1.2832,  1.2752],
        [-1.8615,  1.8252],
        [-1.2491,  1.7049]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-0.3203,  0.4444],
        [-1.1810,  1.4981],
        [-1.6844,  1.8690],
        [-0.0438,  0.3523],
        [-1.5693,  1.7938],
        [-0.4237,  0.9153],
        [-1.2324,  1.6647],
        [-0.0303,  0.2372],
        [-0.8475,  1.1487],
        [ 0.2991,  0.0654],
        [-0.0675,  0.3478],
        [-0.0140,  0.2244]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 0.6676, -0.3297],
        [-1.0477,  1.3695],
        [-1.5831,  1.6639],
        [-1.9354,  2.1560],
        [-1.8026,  1.9475],
        [-0.8506,  0.8479],
        [-2.1629,  2.1673],
        [-1.1020,  1.4352],
        [-0.7756,  0.9951],
        [-1.3198,  1.4534],
        [-0.6868,  0.8850],
        [-1.1547,  1.1531]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 0.1564,  0.0700],
        [-1.4484,  1.7026],
        [-1.6633,  1.6675],
        [-0.6755,  0.9423],
        [-2.3373,  2.3529],
        [-0.5489,  0.7646],
        [-0.2534,  0.2914],
        [-0.2812,  0.3903],
        [-2.1380,  2.1599],
        [-0.2825,  0.3418],
        [-0.9414,  1.2106],
        [-2.0838,  2.2063]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[-0.6307,  1.0934],
        [-0.0826,  0.3985],
        [-0.7805,  1.1062],
        [-1.4383,  1.6243],
        [-0.5959,  0.6789],
        [-1.3764,  1.3599],
        [-1.2724,  1.5560],
        [-1.9581,  2.0873],
        [-0.4434,  0.5277],
        [-0.6499,  0.8828],
        [-1.2080,  1.2223],
        [-1.4388,  1.6205]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-0.9572,  1.1577],
        [-1.4990,  1.5456],
        [-2.1608,  2.2172],
        [-2.3934,  2.4189],
        [-2.0178,  2.0704],
        [-0.6062,  0.7514],
        [-1.2320,  1.2523],
        [-1.1636,  1.3316],
        [ 1.4329, -1.0201],
        [ 1.1623, -0.6812],
        [ 1.2628, -0.7902],
        [ 1.8880, -1.3743]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-0.7736,  0.9150],
        [-1.3479,  1.4102],
        [ 1.1218, -0.7994],
        [-1.7729,  1.9594],
        [-0.3586,  0.5028],
        [-1.2989,  1.7443],
        [-2.3447,  2.3737],
        [-0.7177,  1.0141],
        [-2.0126,  2.0636],
        [-0.9618,  1.1738],
        [-0.3884,  0.4245],
        [-1.6992,  1.8648]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-1.6855,  1.8434],
        [-1.2162,  1.5396],
        [-0.2057,  0.4039],
        [-2.7200,  2.6950],
        [-2.0135,  2.0251],
        [-2.0650,  2.2422],
        [-0.9190,  1.0657],
        [-1.1319,  1.1453],
        [ 0.3472, -0.1516],
        [-1.0040,  1.1883],
        [-0.8559,  1.1564],
        [-0.8844,  1.1791]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-1.2875,  1.5446],
        [-1.3623,  1.5114],
        [-1.5402,  1.6251],
        [-2.5652,  2.4924],
        [-1.7669,  1.9456],
        [-0.2736,  0.4792],
        [-1.3585,  1.3984],
        [-0.3160,  0.5588],
        [-0.3514,  0.4038],
        [ 0.2905,  0.0110],
        [-1.0276,  1.1804],
        [-0.0856,  0.4115]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-1.2970,  1.3679],
        [-0.9857,  1.3763],
        [-1.2732,  1.1291],
        [ 0.0834,  0.3158],
        [-0.5175,  0.9703],
        [-1.4476,  1.4305],
        [-0.3577,  0.5176],
        [ 0.3252,  0.1886],
        [-1.0534,  1.2978],
        [-1.9589,  2.1327],
        [-1.8335,  2.0772],
        [-2.4341,  2.3567]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-0.7709,  0.9906],
        [-0.9446,  1.2194],
        [ 0.2517, -0.1324],
        [-0.1569,  0.3127],
        [-0.3038,  0.4881],
        [-0.5796,  0.8608],
        [-0.5865,  0.7688],
        [-0.2884,  0.5743],
        [-0.1718,  0.4222],
        [-1.8798,  1.9184],
        [-1.3885,  1.5025],
        [-1.1828,  1.1383]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[ 0.3421, -0.1448],
        [-1.8520,  1.8837],
        [-0.7936,  1.0262],
        [ 0.6359, -0.4630],
        [-1.9458,  1.9522],
        [-1.2158,  1.4707],
        [-2.0254,  1.8866],
        [ 0.8067, -0.6026],
        [-0.1721,  0.4974],
        [ 0.1680,  0.2980],
        [-2.5819,  2.7890],
        [-1.0373,  1.3519]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-0.0588,  0.2791],
        [-1.9661,  2.0010],
        [-1.4716,  1.4861],
        [-0.5727,  0.8250],
        [-0.4023,  0.6987],
        [-1.3553,  1.5268],
        [-1.7121,  1.8382],
        [-0.1307,  0.3192],
        [-0.8155,  1.1770],
        [ 0.5229, -0.1501],
        [-2.3499,  2.2539],
        [-0.4819,  0.5859]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 0.3297,  0.1223],
        [ 0.2248, -0.1507],
        [-0.2702,  0.6807],
        [-2.6296,  2.8106],
        [-0.4709,  0.7562],
        [-1.8649,  1.9217],
        [-1.4473,  1.3422],
        [-2.3726,  2.3316],
        [-1.2690,  1.3803],
        [-0.9190,  0.9774],
        [-0.8404,  1.0207],
        [-1.2651,  1.2666]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 0.0906,  0.2461],
        [-1.2681,  1.4256],
        [-1.6405,  1.6977],
        [-1.9582,  1.9921],
        [-2.5781,  2.4831],
        [-0.0611,  0.2436],
        [-1.8072,  1.9769],
        [-0.2635,  0.5530],
        [-2.1384,  2.1367],
        [-0.1128,  0.0796],
        [-1.8976,  2.0030],
        [-1.8286,  1.9300]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[-0.6928,  0.6721],
        [-1.5492,  1.8893],
        [-2.1812,  2.3186],
        [-0.9570,  1.2390],
        [ 0.0047,  0.2970],
        [-1.0398,  1.1708],
        [-1.8798,  2.1190],
        [-0.9138,  1.0942],
        [-1.3380,  1.4065],
        [-1.8587,  1.8371],
        [-0.8862,  1.0001],
        [-1.7024,  1.7488]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-1.5576,  1.8125],
        [-1.3629,  1.5836],
        [-2.3111,  2.3954],
        [-1.6486,  2.1051],
        [-1.2224,  1.3273],
        [-1.2724,  1.4620],
        [-1.4371,  1.5125],
        [-1.9924,  1.9704],
        [ 0.4052, -0.1463],
        [-0.4464,  0.8600],
        [-0.1544,  0.4887],
        [ 0.6335, -0.3834]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-0.9476,  1.2679],
        [-1.3400,  1.4434],
        [ 0.3439, -0.1481],
        [-0.6786,  0.9005],
        [-0.4584,  0.6516],
        [-0.3938,  0.6889],
        [-1.1512,  1.3386],
        [-2.2871,  2.2925],
        [-1.6618,  1.8727],
        [ 0.0948,  0.1178],
        [-0.6155,  0.7772],
        [ 0.6013, -0.3180]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-0.5064,  0.7350],
        [-0.7704,  1.1838],
        [-1.3413,  1.4308],
        [-2.1553,  2.0455],
        [-0.9673,  1.3023],
        [-1.8521,  2.0107],
        [-1.2321,  1.1950],
        [-1.3089,  1.4571],
        [-0.3324,  0.6860],
        [-2.0062,  1.9010],
        [-0.5991,  0.7270],
        [-2.2475,  2.2431]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-1.5183,  1.6454],
        [-1.3484,  1.4147],
        [-2.9669,  2.8623],
        [-1.5030,  1.5537],
        [-1.4126,  1.4586],
        [-0.9591,  1.0619],
        [-1.4049,  1.5051],
        [-1.1683,  1.1752],
        [-0.1838,  0.2344],
        [-0.9264,  0.9463],
        [-1.1216,  1.2227],
        [-0.4288,  0.6367]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-0.8404,  0.9920],
        [-1.8674,  2.0137],
        [-1.3622,  1.3964],
        [-1.1974,  1.3989],
        [-0.9086,  1.0053],
        [-1.4765,  1.5744],
        [-1.3837,  1.5802],
        [ 0.7365, -0.1647],
        [-0.7944,  0.8697],
        [-1.8394,  2.1398],
        [-2.1945,  2.3906],
        [-2.5639,  2.5765]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-1.0232,  1.2925],
        [-1.1807,  1.3536],
        [-0.4110,  0.6499],
        [-0.9956,  1.0205],
        [-0.0827,  0.3437],
        [-1.6173,  1.7632],
        [ 0.2577, -0.1311],
        [-1.0844,  1.4463],
        [ 1.0273, -0.7634],
        [-2.6577,  2.7519],
        [ 0.9635, -0.4361],
        [-0.7613,  1.0017]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-0.7053,  0.8197],
        [-0.3685,  0.3860],
        [-0.7100,  1.0524],
        [-0.5785,  0.8815],
        [ 0.0689,  0.2856],
        [-2.0564,  2.3534],
        [ 1.7282, -1.2554],
        [ 0.2984, -0.0331],
        [-0.0293,  0.1919],
        [-0.4428,  0.4257],
        [-1.7620,  1.7417],
        [-1.5813,  1.8242]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[ 0.3580, -0.0336],
        [-0.8683,  1.0922],
        [-0.4247,  0.7425],
        [-0.0632,  0.3182],
        [-2.7660,  2.8072],
        [-0.7825,  0.8800],
        [-2.2394,  2.5162],
        [ 1.2138, -0.7080],
        [ 0.3159,  0.0171],
        [ 1.3892, -0.9861],
        [-1.9961,  2.0591],
        [-0.9394,  1.1074]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 0.8034, -0.4511],
        [-0.2365,  0.6143],
        [-0.5986,  0.7227],
        [-1.7797,  1.9920],
        [-1.2588,  1.3806],
        [ 0.4739, -0.2254],
        [-0.7007,  0.9941],
        [-2.3652,  2.5200],
        [-0.3794,  0.6171],
        [-0.1505,  0.3716],
        [-1.4903,  1.6856],
        [-0.6157,  0.6727]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[-0.2643,  0.5784],
        [ 0.3229, -0.0604],
        [ 0.0329,  0.2776],
        [-1.8137,  1.8481],
        [-2.0706,  1.9303],
        [-1.8179,  1.9799],
        [ 0.8415, -0.6660],
        [ 2.2186, -1.8324],
        [-1.8144,  1.9256],
        [-1.0725,  0.9899],
        [-1.3623,  1.6019],
        [-1.0470,  1.2229]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[-1.1958,  1.4082],
        [-1.6721,  1.7626],
        [-0.1549,  0.3988],
        [-1.8803,  2.1594],
        [ 0.1458,  0.2335],
        [-1.1200,  1.2428],
        [-1.8927,  2.0406],
        [-1.3406,  1.4334],
        [ 0.1119,  0.2261],
        [-0.9028,  1.0229],
        [-1.7390,  1.8230],
        [-1.3769,  1.4406]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-1.5106,  1.6843],
        [-2.3772,  2.4556],
        [-1.9369,  2.0713],
        [-2.0986,  2.2180],
        [-1.5327,  1.7557],
        [-1.4463,  1.6494],
        [-1.8966,  1.6223],
        [-1.8238,  1.9256],
        [ 0.3352,  0.0743],
        [-0.7327,  1.0432],
        [-0.2314,  0.5513],
        [ 1.1166, -0.8416]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-2.0063,  2.1519],
        [ 0.1759,  0.1139],
        [ 0.5953, -0.2751],
        [-0.4023,  0.6797],
        [-2.0507,  2.2640],
        [-0.0305,  0.3382],
        [-2.5680,  2.6380],
        [-2.3573,  2.3225],
        [-1.9668,  2.0975],
        [-0.2027,  0.2807],
        [ 0.5944, -0.2733],
        [-0.0251,  0.1853]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-0.6130,  0.5422],
        [-1.9772,  2.2460],
        [-0.7422,  0.8137],
        [-1.5583,  1.7436],
        [-1.1620,  1.4126],
        [-0.8547,  1.1039],
        [-1.0685,  0.9514],
        [-0.9660,  1.2163],
        [-1.3024,  1.4835],
        [-1.1684,  1.5272],
        [-1.8317,  1.9614],
        [-1.0576,  1.2370]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-1.8759,  2.1183],
        [-1.9523,  2.2032],
        [-2.2934,  2.1417],
        [-1.7484,  2.0378],
        [-1.3802,  1.5794],
        [ 0.1377,  0.1590],
        [-1.3165,  1.6753],
        [-2.0363,  2.1605],
        [ 0.0334,  0.1848],
        [-0.8753,  1.0493],
        [-0.3284,  0.4327],
        [-0.6982,  1.1545]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-1.4799,  1.6598],
        [-0.3249,  0.5907],
        [-0.4984,  0.6257],
        [-0.8051,  1.0486],
        [-1.3058,  1.6168],
        [-1.8618,  2.0856],
        [ 0.5784, -0.4754],
        [-0.7223,  0.9383],
        [-1.9708,  2.2469],
        [-1.5555,  1.8470],
        [-0.7546,  1.0967],
        [-2.3961,  2.4173]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-1.0819,  1.1693],
        [-1.1251,  1.3809],
        [-0.0427,  0.3083],
        [-0.0132,  0.4441],
        [ 0.0979, -0.0101],
        [-0.8048,  0.8607],
        [ 0.7332, -0.4733],
        [-1.1875,  1.7052],
        [-0.2741,  0.4991],
        [-1.7762,  1.7405],
        [-1.1021,  1.2557],
        [ 0.6429, -0.1519]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[ 0.0159,  0.2252],
        [-1.6768,  1.7348],
        [-1.0239,  1.3455],
        [ 0.1307,  0.1237],
        [-1.4897,  1.7421],
        [-2.4622,  2.6903],
        [ 0.0350,  0.3132],
        [ 0.6445, -0.3575],
        [ 0.1091,  0.3587],
        [-1.3103,  1.4349],
        [-1.9332,  1.9929],
        [-2.3443,  2.4319]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[ 0.1488,  0.2807],
        [-1.0632,  1.4003],
        [-1.4731,  1.7313],
        [-0.0403,  0.3321],
        [-0.2567,  0.6338],
        [-1.2176,  1.3168],
        [-1.3570,  1.3781],
        [-0.1210,  0.3931],
        [ 0.7837, -0.5262],
        [-0.8145,  0.9667],
        [-1.9719,  2.2462],
        [ 0.5455, -0.2489]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 5.6773e-01, -4.5858e-01],
        [ 1.2510e+00, -8.2660e-01],
        [ 3.3895e-01, -7.3217e-02],
        [-2.6430e+00,  2.7315e+00],
        [-2.0694e+00,  2.2215e+00],
        [ 7.6113e-01, -1.9565e-01],
        [-2.6555e+00,  3.0346e+00],
        [-2.2734e+00,  2.4551e+00],
        [-1.8965e+00,  1.9077e+00],
        [-2.2858e+00,  2.2301e+00],
        [-1.2724e+00,  1.3183e+00],
        [ 9.7059e-02,  2.8953e-03]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 1.6141, -0.9718],
        [-1.5136,  1.7044],
        [-0.6916,  0.6404],
        [-1.4373,  1.6159],
        [-2.0757,  2.2049],
        [ 0.1655,  0.1855],
        [-0.9739,  1.1653],
        [ 0.9753, -0.6151],
        [-1.6975,  1.9234],
        [ 0.8435, -0.4776],
        [-0.9222,  1.3328],
        [-1.5748,  2.0088]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[-1.1986,  1.4648],
        [-1.0694,  1.2942],
        [-1.4211,  1.6119],
        [-2.4210,  2.5901],
        [ 0.3712, -0.1888],
        [-1.6044,  1.8677],
        [-2.3558,  2.4872],
        [-2.2306,  2.2461],
        [ 0.5559, -0.2011],
        [-2.3197,  2.3940],
        [-1.7261,  1.8267],
        [-2.2165,  2.2531]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-1.1309,  1.3343],
        [-0.3460,  0.7118],
        [-2.1845,  2.1246],
        [ 0.2493,  0.0593],
        [-1.5254,  1.6647],
        [-1.8545,  1.8837],
        [-2.1446,  2.2885],
        [-1.8243,  2.1138],
        [ 0.0653,  0.3757],
        [ 1.0273, -0.7318],
        [-1.1047,  1.2600],
        [-1.2017,  1.1715]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-1.3384,  1.5257],
        [-1.2583,  1.5228],
        [ 1.1199, -0.7765],
        [-0.6535,  0.8286],
        [-0.4011,  0.7585],
        [-0.1463,  0.5581],
        [-2.3219,  2.3436],
        [-1.8988,  1.9774],
        [-2.0916,  1.9846],
        [ 0.4145, -0.1729],
        [ 1.5557, -1.0494],
        [ 0.6586, -0.4876]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-0.4994,  0.7089],
        [-2.2631,  2.4050],
        [-0.3289,  0.5218],
        [-2.0180,  2.2829],
        [-0.5507,  0.7604],
        [-0.5157,  0.8319],
        [ 0.1244,  0.2250],
        [-0.8832,  1.0782],
        [-0.0853,  0.5718],
        [-2.5468,  2.6369],
        [-1.0650,  1.4027],
        [-2.2156,  2.2022]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[ 0.8303, -0.5494],
        [-1.4658,  1.8256],
        [-2.0597,  2.1862],
        [-0.4425,  0.7858],
        [-2.3083,  2.2834],
        [ 0.5936, -0.1305],
        [-2.1506,  2.1582],
        [-0.7687,  0.9433],
        [ 0.8101, -0.4879],
        [-0.9515,  1.1942],
        [-0.2014,  0.4414],
        [-0.7805,  0.8334]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-1.6336e+00,  1.8299e+00],
        [-1.8438e+00,  2.0371e+00],
        [-2.0124e+00,  2.0478e+00],
        [-1.8648e+00,  2.2078e+00],
        [-2.2212e+00,  2.1254e+00],
        [-1.8499e+00,  1.8700e+00],
        [-8.3786e-01,  1.0932e+00],
        [-4.1158e-01,  4.4449e-01],
        [ 6.5610e-04,  3.3213e-01],
        [-1.0082e+00,  1.2328e+00],
        [-3.0637e+00,  3.1467e+00],
        [-2.9503e+00,  3.0833e+00]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[ 0.3797, -0.0355],
        [-2.3282,  2.4697],
        [ 1.2303, -0.6710],
        [-0.4832,  0.7732],
        [ 0.0581,  0.2964],
        [ 0.7283, -0.3352],
        [-0.1402,  0.4892],
        [-1.8690,  1.7077],
        [-0.6825,  0.7732],
        [-2.2155,  2.4126],
        [-0.0739,  0.2128],
        [ 0.2043,  0.2560]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[ 0.0647,  0.1716],
        [-1.7262,  1.8368],
        [-1.6277,  1.9283],
        [ 0.5676, -0.1655],
        [-0.8558,  1.1067],
        [-0.7658,  1.0255],
        [ 0.5356, -0.1674],
        [-0.0841,  0.4253],
        [-0.7740,  1.1429],
        [ 0.3964, -0.1313],
        [-1.2536,  1.5745],
        [-1.6311,  1.5540]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[ 0.2186,  0.2172],
        [-0.8133,  1.0819],
        [-1.2076,  1.3666],
        [ 1.4115, -0.7837],
        [-1.2674,  1.3540],
        [-0.7121,  0.9150],
        [-1.6938,  1.7870],
        [ 0.6073, -0.0274],
        [ 0.9454, -0.5875],
        [ 1.6355, -1.2327],
        [-0.4453,  0.3672],
        [-0.6819,  1.0424]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[-0.1930,  0.4478],
        [ 0.5013, -0.2268],
        [-0.6612,  1.0055],
        [-1.0568,  1.4546],
        [-1.9520,  2.2329],
        [-1.8124,  2.0425],
        [-1.2319,  1.4477],
        [-0.7543,  0.8913],
        [-0.5675,  0.7757],
        [-1.6699,  1.6647],
        [-0.5678,  0.9377],
        [-0.7460,  0.9146]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 0.5466, -0.1159],
        [-0.4164,  0.6359],
        [-1.6546,  1.7853],
        [-0.9290,  1.2121],
        [-2.3135,  2.5527],
        [-0.5245,  1.0081],
        [-0.0218,  0.3477],
        [ 1.2506, -0.8477],
        [-0.0486,  0.6895],
        [ 0.9978, -0.6341],
        [-1.3843,  1.5738],
        [-0.9061,  1.2774]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[-2.6144,  2.8132],
        [ 1.0879, -0.7130],
        [-1.9155,  2.1926],
        [-2.1349,  2.3676],
        [ 0.5340,  0.0141],
        [-1.7814,  1.9184],
        [-1.0950,  1.4152],
        [-0.5020,  0.9258],
        [ 0.9389, -0.6081],
        [-1.3373,  1.5974],
        [-0.7785,  1.0794],
        [ 0.1449,  0.1827]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[ 0.9690, -0.3418],
        [-0.0674,  0.6469],
        [-1.3660,  1.6600],
        [-1.0392,  1.2785],
        [ 0.0098,  0.1929],
        [-1.2964,  1.6900],
        [-1.5593,  1.7818],
        [-1.2357,  1.3853],
        [ 0.2325,  0.1302],
        [ 1.3962, -0.7489],
        [ 0.1621,  0.0744],
        [ 0.4216, -0.0859]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-0.7450,  1.0354],
        [-0.1225,  0.5929],
        [ 1.9364, -1.5647],
        [-0.6024,  0.8591],
        [-0.8069,  0.8078],
        [-2.0151,  2.2396],
        [-2.0754,  2.3535],
        [-1.2345,  1.5245],
        [-1.4227,  1.6248],
        [-1.5604,  1.7842],
        [ 0.4516, -0.0853],
        [-0.1586,  0.3162]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-1.0740,  1.2046],
        [-1.4180,  1.5503],
        [-0.9566,  1.1352],
        [-2.8902,  2.9245],
        [-1.3834,  1.5925],
        [-0.4919,  0.7916],
        [-1.3054,  1.5425],
        [-1.7255,  1.7139],
        [ 0.7201, -0.3553],
        [-0.4969,  0.8708],
        [-0.8290,  1.0291],
        [-1.2039,  1.1157]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-1.3320,  1.6730],
        [-0.7838,  1.1591],
        [-2.9106,  2.9454],
        [-1.3704,  1.6591],
        [-2.3730,  2.4253],
        [-0.9395,  1.0332],
        [-1.5026,  1.7725],
        [-0.1615,  0.6228],
        [ 0.7181, -0.1487],
        [-2.2495,  2.3567],
        [-0.4999,  0.7823],
        [-1.7435,  1.8337]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-1.4839,  1.5124],
        [-1.0127,  1.0505],
        [-1.6027,  1.7941],
        [ 0.6666, -0.2374],
        [-2.1288,  2.3586],
        [-1.0965,  1.3010],
        [ 0.2446, -0.1054],
        [-1.2904,  1.4318],
        [-1.0254,  1.0674],
        [-1.1947,  1.6893],
        [-1.4259,  1.5952],
        [-1.4982,  1.8136]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[ 1.1170, -0.5058],
        [-0.6586,  1.0396],
        [-1.2610,  1.3126],
        [ 0.0762,  0.1880],
        [ 0.5160, -0.2235],
        [ 1.0506, -0.6108],
        [ 1.0172, -0.5675],
        [-0.5630,  1.0242],
        [-0.2013,  0.3967],
        [-0.8126,  1.0269],
        [ 0.3354,  0.0896],
        [ 1.7745, -1.3216]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[ 0.2765,  0.1192],
        [-1.7738,  2.0643],
        [-0.5602,  0.6501],
        [ 1.8357, -1.3847],
        [-1.8815,  2.0792],
        [-1.0140,  1.4841],
        [ 1.0900, -0.6557],
        [-0.3257,  0.6872],
        [-1.5234,  1.8202],
        [-1.3844,  1.5821],
        [-1.6776,  1.7894],
        [-2.7779,  2.8567]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-0.1898,  0.4506],
        [-0.1232,  0.7544],
        [-1.3224,  1.5284],
        [-1.3583,  1.6198],
        [-0.8821,  1.4231],
        [-1.8588,  2.1461],
        [-1.1287,  1.6333],
        [-0.0593,  0.3656],
        [ 0.9029, -0.7258],
        [ 0.9271, -0.5873],
        [-0.1094,  0.4745],
        [-0.7793,  0.9943]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[ 0.4561, -0.1921],
        [-0.5793,  0.7872],
        [-0.4934,  0.9561],
        [-2.6579,  2.7320],
        [-2.6046,  2.7021],
        [-0.0211,  0.4791],
        [-1.6901,  1.9361],
        [-0.3226,  0.5494],
        [-0.7844,  0.8816],
        [-1.5711,  1.8056],
        [-1.3783,  1.5003],
        [-1.7368,  1.9256]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 0.5980, -0.2706],
        [-0.5175,  0.6523],
        [-2.2446,  2.3716],
        [-2.3571,  2.5549],
        [-2.8246,  3.0218],
        [-1.6883,  1.8399],
        [-0.5700,  0.8328],
        [ 1.4811, -0.9433],
        [-1.4724,  1.5750],
        [-0.9614,  1.2268],
        [-2.5715,  2.6003],
        [-1.4447,  1.5820]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[ 1.2670e-01,  2.6254e-01],
        [ 1.9913e-01,  4.8420e-02],
        [ 2.9214e-01,  1.0212e-01],
        [-2.7724e+00,  2.8450e+00],
        [ 1.2918e+00, -9.1308e-01],
        [-3.0580e-01,  6.6829e-01],
        [ 3.5328e-01,  2.2722e-03],
        [-1.3501e+00,  1.5386e+00],
        [ 1.5239e+00, -1.1412e+00],
        [-2.6699e+00,  2.6673e+00],
        [-8.4564e-01,  1.1824e+00],
        [-8.5106e-01,  1.0891e+00]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[ 0.1689,  0.0183],
        [-0.1245,  0.5957],
        [-0.4297,  0.7279],
        [-0.4453,  0.6469],
        [-1.3688,  1.5734],
        [-0.6616,  0.9405],
        [-0.3446,  0.7858],
        [-0.2701,  0.7236],
        [ 0.8964, -0.4887],
        [ 1.3751, -0.9914],
        [ 0.3653, -0.0916],
        [ 0.9209, -0.6946]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[ 0.1336,  0.1867],
        [ 1.0032, -0.6543],
        [ 1.4826, -1.1037],
        [-1.4436,  1.5826],
        [ 0.2327,  0.1297],
        [ 0.6298, -0.4280],
        [ 0.5492, -0.3030],
        [-1.9320,  2.0668],
        [-1.3948,  1.6374],
        [ 1.3370, -0.9726],
        [ 1.8228, -1.3125],
        [ 1.2284, -0.6089]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-0.1482,  0.4712],
        [-0.6064,  0.9490],
        [ 0.6294, -0.2711],
        [-1.0409,  1.3746],
        [-2.3140,  2.3578],
        [ 0.9124, -0.3678],
        [-0.2361,  0.4803],
        [-0.1335,  0.5094],
        [-0.3363,  0.6807],
        [-1.0553,  1.4076],
        [-2.7813,  2.7095],
        [-1.8035,  1.9185]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[ 1.5935, -0.9870],
        [ 1.3811, -0.7911],
        [-3.2444,  3.3271],
        [-2.0435,  2.2660],
        [-0.2456,  0.5487],
        [-0.2705,  0.5729],
        [-1.6164,  1.8338],
        [ 1.0357, -0.6284],
        [ 0.0120,  0.4581],
        [-2.5068,  2.6080],
        [ 0.4947, -0.1866],
        [-0.4492,  0.7483]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[ 1.5708, -0.9793],
        [-1.7218,  1.9276],
        [-1.9088,  1.9623],
        [-1.3547,  1.6814],
        [-0.9671,  1.3080],
        [-1.0582,  1.2811],
        [-0.0887,  0.4859],
        [ 0.4018, -0.0260],
        [-0.5999,  0.7854],
        [-1.3077,  1.5927],
        [-2.5887,  2.6259],
        [-1.1805,  1.2845]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-0.1983,  0.5515],
        [-0.4866,  0.8505],
        [-0.1299,  0.2714],
        [-0.4958,  0.8521],
        [-0.3225,  0.4711],
        [-1.1063,  1.3818],
        [ 0.6330, -0.0675],
        [-2.2244,  2.2779],
        [-0.3584,  0.5702],
        [-2.1496,  2.3238],
        [ 0.6529, -0.3512],
        [-0.9727,  1.1009]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[ 0.6933, -0.1545],
        [-2.4491,  2.6469],
        [-1.3663,  1.6086],
        [ 1.3452, -0.7178],
        [-1.4881,  1.4126],
        [-2.3770,  2.5171],
        [ 1.2211, -0.8789],
        [-1.5783,  1.9574],
        [-2.1739,  2.1620],
        [-2.2606,  2.4554],
        [-1.7686,  1.9967],
        [-3.2494,  3.2276]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[ 1.2996, -0.8038],
        [-1.0486,  1.4087],
        [-1.9998,  2.2646],
        [ 0.4968, -0.0247],
        [-1.6849,  1.9317],
        [-2.6961,  2.7508],
        [-1.4489,  1.6785],
        [ 0.9734, -0.6031],
        [ 1.5735, -1.1027],
        [-1.7182,  1.9765],
        [-0.6031,  0.8088],
        [-2.3510,  2.5665]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[-0.2008,  0.6923],
        [ 1.1558, -0.7937],
        [-0.5102,  0.7744],
        [-1.8972,  2.1232],
        [-0.8281,  1.2504],
        [-0.0923,  0.2267],
        [-1.6425,  1.6425],
        [-3.0769,  3.0174],
        [ 0.0883,  0.4585],
        [ 0.6343, -0.2501],
        [ 0.9176, -0.4837],
        [-0.3851,  0.7432]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[ 1.1855, -0.7870],
        [-0.9992,  1.4316],
        [-0.2407,  0.4448],
        [-1.2561,  1.4139],
        [-2.0363,  2.3215],
        [-0.1392,  0.4293],
        [-1.7528,  1.8856],
        [ 1.8421, -1.2614],
        [-2.2548,  2.3502],
        [-0.0548,  0.2828],
        [-1.4713,  1.4592],
        [-0.7200,  0.9440]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[-2.0766,  2.3458],
        [-1.3813,  1.2979],
        [-0.7577,  1.0923],
        [-2.0972,  2.1271],
        [-0.1677,  0.7938],
        [-0.7095,  0.8515],
        [-2.5468,  2.8391],
        [-1.5713,  1.7937],
        [ 1.2735, -0.8905],
        [-0.7381,  1.2639],
        [-3.0965,  3.1793],
        [-2.3072,  2.4011]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-2.9969,  3.0068],
        [-1.3147,  1.7521],
        [-1.1878,  1.3843],
        [-2.0141,  2.3039],
        [-1.8656,  2.1281],
        [-2.5170,  2.6462],
        [-1.1820,  1.3111],
        [-2.8459,  2.9185],
        [ 0.8710, -0.4854],
        [ 0.1929,  0.2980],
        [-0.8860,  1.2163],
        [ 0.1115,  0.1506]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-2.2508,  2.4104],
        [-2.9037,  2.9517],
        [ 0.3365,  0.2013],
        [-2.2438,  2.5249],
        [-2.6829,  2.9354],
        [-2.6585,  2.8135],
        [-2.3576,  2.6697],
        [-1.3671,  1.6137],
        [-0.6127,  0.9721],
        [-2.0646,  2.2967],
        [ 0.0570,  0.2743],
        [-2.0770,  2.3712]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-1.5719,  1.8353],
        [-1.2776,  1.6214],
        [-0.2203,  0.5121],
        [-1.4044,  1.8518],
        [-1.7635,  2.0057],
        [-0.6277,  0.8770],
        [-0.0705,  0.4260],
        [-0.5085,  0.9010],
        [ 0.3344,  0.2353],
        [-1.0264,  1.4916],
        [-0.8683,  1.1034],
        [-3.1102,  3.0618]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-1.8839,  2.4505],
        [ 0.5751, -0.0545],
        [-2.5932,  2.7658],
        [ 0.1925,  0.2553],
        [-0.6425,  0.9109],
        [ 0.3444,  0.1138],
        [-0.0082,  0.2678],
        [ 1.0106, -0.7013],
        [-0.6949,  1.0731],
        [-2.6084,  2.7235],
        [-0.8771,  1.2619],
        [ 1.3153, -0.6153]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-2.0585,  2.3090],
        [-1.1644,  1.5629],
        [-2.3397,  2.4601],
        [ 0.8955, -0.4890],
        [-0.5443,  1.0388],
        [-2.9196,  3.1277],
        [ 0.0355,  0.5011],
        [ 0.1400,  0.3190],
        [-1.3232,  1.5514],
        [-2.6214,  2.7623],
        [-2.9872,  3.1472],
        [-2.3923,  2.4988]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-3.4264,  3.4784],
        [-3.3861,  3.5625],
        [-1.0318,  1.2774],
        [ 0.0952,  0.4060],
        [-2.8028,  2.9632],
        [-1.9482,  2.2313],
        [-2.5658,  2.7684],
        [-2.4721,  2.6909],
        [-0.5205,  1.0444],
        [-3.5899,  3.6226],
        [-2.3415,  2.4610],
        [-0.0081,  0.4043]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-2.0095,  2.1879],
        [-3.4886,  3.4506],
        [-3.5979,  3.6074],
        [-2.2647,  2.5034],
        [-1.6830,  1.6825],
        [-3.1238,  3.1405],
        [-1.4317,  1.6834],
        [-1.3688,  1.7453],
        [-2.6432,  2.8870],
        [-1.9765,  2.1644],
        [-1.8741,  2.2290],
        [-3.6624,  3.7099]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-2.0037,  2.1128],
        [-1.1760,  1.3825],
        [-2.2669,  2.3807],
        [-1.8931,  2.1489],
        [-2.5567,  2.8781],
        [-1.1745,  1.5695],
        [-3.2581,  3.2876],
        [-0.2173,  0.4366],
        [-1.9889,  2.4667],
        [-1.9496,  2.1858],
        [-1.9118,  2.0221],
        [-3.5620,  3.6379]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[-3.2464,  3.3439],
        [-0.5769,  0.8069],
        [-1.6748,  1.8166],
        [-1.8798,  2.3181],
        [-2.0506,  2.3361],
        [-3.0221,  2.9703],
        [-3.7221,  3.5904],
        [-2.0866,  2.4347],
        [-0.7939,  1.0364],
        [-2.0880,  2.2402],
        [-0.7059,  1.1076],
        [-2.8339,  3.0224]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[-0.4543,  0.8318],
        [ 0.1423,  0.2103],
        [-2.0019,  2.3031],
        [-2.4434,  2.4698],
        [-3.5761,  3.6408],
        [-2.2397,  2.3400],
        [-0.6968,  0.9930],
        [ 0.7166, -0.4046],
        [-3.4391,  3.2493],
        [-2.6531,  2.6086],
        [-3.4273,  3.3969],
        [ 1.1073, -0.6944]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[-1.7956,  1.9690],
        [-1.8950,  2.2740],
        [-0.2991,  0.6111],
        [-3.4100,  3.2649],
        [-1.5523,  2.0362],
        [-1.5788,  1.9942],
        [-0.5380,  0.9982],
        [-2.4248,  2.8012],
        [-0.4334,  0.7556],
        [-0.2175,  0.4046],
        [-2.9554,  2.9868],
        [-0.9719,  1.5046]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-3.0933,  3.2064],
        [ 0.2553,  0.3004],
        [-3.0513,  3.1414],
        [-1.5797,  1.6773],
        [-0.0034,  0.5177],
        [-1.5789,  1.8875],
        [-2.4323,  2.5300],
        [-2.7277,  2.9222],
        [-0.3321,  0.6497],
        [-0.8218,  1.1473],
        [-0.6784,  0.9762],
        [ 0.6169, -0.3111]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-3.0651,  3.0331],
        [-1.4849,  1.3557],
        [ 1.7065, -1.2641],
        [-1.8036,  2.0596],
        [-2.4024,  2.5210],
        [-2.9851,  2.9922],
        [-3.7000,  3.4489],
        [-2.8428,  2.7571],
        [-2.9332,  2.9061],
        [-2.0522,  1.9722],
        [-0.8703,  0.8151],
        [-2.5936,  2.5900]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-1.5386,  1.4916],
        [-2.3685,  2.3446],
        [-2.3488,  2.1924],
        [-2.1454,  1.9566],
        [-2.0260,  1.9575],
        [-2.1313,  1.9006],
        [-2.3501,  2.2783],
        [-2.8941,  2.8280],
        [-1.7660,  1.6123],
        [-1.1764,  0.9957],
        [-1.7710,  1.6640],
        [-2.8458,  2.7959]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #50: tensor([[-3.2830,  2.9913],
        [-1.5775,  1.9332],
        [-2.4529,  2.5381],
        [-2.2281,  2.2004],
        [-2.3267,  2.1247],
        [-1.1913,  1.2639],
        [-2.2973,  2.0772],
        [-0.1605,  0.3408],
        [ 1.1798, -1.0045],
        [-2.1701,  2.0584],
        [-0.1609,  0.3087],
        [-2.4714,  2.2362]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #100: tensor([[-2.4737,  2.4004],
        [-2.4515,  2.2975],
        [-2.8603,  2.9863],
        [ 1.6949, -1.3930],
        [-2.4906,  2.2539],
        [-2.3570,  2.2315],
        [ 1.5128, -1.3051],
        [-1.4524,  1.5447],
        [-0.9173,  0.8663],
        [-2.0051,  1.9993],
        [-2.3664,  2.2708],
        [-2.2022,  2.3493]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #150: tensor([[-3.0863,  3.0432],
        [-3.2554,  2.9968],
        [-1.2129,  1.0031],
        [ 0.1554, -0.0445],
        [-2.4355,  2.3877],
        [-2.9355,  2.9478],
        [-2.6914,  2.5935],
        [-0.4681,  0.8489],
        [-1.9058,  1.7217],
        [-2.7869,  2.6925],
        [-2.6609,  2.4719],
        [-1.8036,  1.7696]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #200: tensor([[-1.1435,  1.1503],
        [-2.9249,  2.7346],
        [-2.6304,  2.5236],
        [-2.5079,  2.5492],
        [-2.3780,  2.4638],
        [-2.6427,  2.5591],
        [-2.3965,  2.3675],
        [-1.6736,  1.7098],
        [-1.9923,  1.8331],
        [-1.4054,  1.1626],
        [-2.7638,  2.6626],
        [-3.0015,  2.9596]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #250: tensor([[-1.4041,  1.3477],
        [-1.1018,  1.0931],
        [-2.6440,  2.4945],
        [-2.4332,  2.7296],
        [-1.8319,  1.8821],
        [-2.0498,  2.1675],
        [-2.6763,  2.7361],
        [-2.3887,  2.5632],
        [-2.7495,  2.4590],
        [-2.2537,  2.3395],
        [-2.7603,  2.9693],
        [-2.4659,  2.4896]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #300: tensor([[-2.5837,  2.5774],
        [-1.1215,  1.0297],
        [-2.2223,  2.1784],
        [-2.5217,  2.5098],
        [-2.7596,  2.7950],
        [-2.1405,  2.1110],
        [-2.8856,  2.7599],
        [-3.2963,  3.3173],
        [-2.5288,  2.3961],
        [-2.6279,  2.3808],
        [-0.7011,  0.8302],
        [-1.2670,  1.2965]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #350: tensor([[-2.4351,  2.2523],
        [-2.8230,  2.9375],
        [-2.3145,  2.0213],
        [-2.8118,  2.7637],
        [-3.5021,  3.4134],
        [-3.0473,  3.1385],
        [-2.1071,  2.1955],
        [-2.3050,  2.3494],
        [-2.9488,  2.8420],
        [-2.4354,  2.4956],
        [-3.3735,  3.1826],
        [-2.9220,  2.7817]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #400: tensor([[-1.7750,  1.8614],
        [-2.1208,  1.9629],
        [-3.3140,  3.0459],
        [-2.8248,  2.9272],
        [-2.8680,  2.7971],
        [-2.9797,  2.9982],
        [-2.7851,  2.8473],
        [-3.1913,  3.1783],
        [-2.3648,  2.2052],
        [-3.0610,  3.0501],
        [-3.4974,  3.2602],
        [-3.1254,  2.9769]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #450: tensor([[-3.4305,  3.3442],
        [-2.2388,  2.1794],
        [-3.1980,  3.0262],
        [-0.6671,  0.8085],
        [-1.5816,  1.4316],
        [-2.5947,  2.4155],
        [-1.4519,  1.3129],
        [-1.1954,  1.7020],
        [ 0.3412, -0.2248],
        [ 0.6357, -0.3194],
        [-1.9673,  1.9292],
        [-0.4124,  0.3381]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #500: tensor([[-2.7201,  2.3817],
        [-1.3397,  1.2785],
        [ 0.4055, -0.1229],
        [-2.8890,  2.8365],
        [-2.7257,  2.5247],
        [-2.7001,  2.4958],
        [-2.3645,  2.1803],
        [-2.3923,  2.3686],
        [-2.2314,  2.0710],
        [-1.9415,  1.7433],
        [-2.1519,  2.0136],
        [-1.6669,  1.6475]], device='cuda:0', grad_fn=<AddmmBackward>)
Iter #550: tensor([[-2.4087,  2.3432],
        [-2.3762,  2.2064],
        [-0.9223,  0.9220],
        [-3.0913,  2.9033],
        [-3.0431,  2.9186],
        [-1.2200,  1.1418],
        [-2.3156,  2.2703],
        [-2.9226,  2.7819],
        [-2.4965,  2.4586],
        [-2.4970,  2.6800],
        [-3.0744,  3.1587],
        [-2.8966,  2.7098]], device='cuda:0', grad_fn=<AddmmBackward>)
