{

"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"provenance": []
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3"
},
"language_info": {
"name": "python"
}
},
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "-cQLLWKcUZG4"
},
"outputs": [],
"source": [
"import numpy as np\n",
"#import pytorch\n",
"import torch\n",
"import torch.nn as nn\n",
"import torch.nn.functional as F\n",
"import torch.optim as optim\n",
"import torchvision\n",
"import torchvision.transforms as transforms\n",
"import torchvision.datasets as datasets\n",
"import torchvision.models as models\n",
"#import skimage\n",
"import skimage\n",
"import matplotlib.pyplot as plt"
]
},
{
"cell_type": "code",
"source": [
"import random"
],
"metadata": {
"id": "BYaAj_qiaQU9"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"#create images\n",
"monkee=skimage.io.imread('monkee.jpg')\n",
"monkee=skimage.transform.resize(monkee,(250,250))\n",
"preprocess = transforms.Compose([\n",
" transforms.ToPILImage(),\n",
" transforms.Resize(256),\n",
 " transforms.CenterCrop(224),\n",
" transforms.ToTensor(),\n",
" transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224,
0.225]),\n",
"])\n",
"#create 1500x1500 canvas\n",
"canvas=np.zeros((1500,1500,3))\n",
"x=750-monkee.shape[0]/2\n",
"resnetimages=[]\n",
"ys=[]\n",
"for i in range(200):\n",
" y=random.randint(0,1000)\n",
" canvas[int(y):int(y)+monkee.shape[0],int(x):int(x)
+monkee.shape[1]]=monkee\n",
" yinfivesec=y+(1/2)*9.8*5**2\n",
" ys.append(yinfivesec)\n",
" resnetimages.append(preprocess(canvas))\n",
" canvas=np.zeros((1500,1500,3))\n",
"\n",
"\n",
"\n",
"\n",
"plt.imshow(canvas)"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 452
},
"id": "irUB2gmsXkiD",
"outputId": "cd185526-c2b7-4dec-fe3c-d0f9ab31be0d"
},
"execution_count": null,
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"<matplotlib.image.AxesImage at 0x79f19ea149a0>"
]
},
"metadata": {},
"execution_count": 29
},
{
"output_type": "display_data",
"data": {
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
],
"image/png":
"iVBORw0KGgoAAAANSUhEUgAAAbIAAAGiCAYAAACCpUOHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIH
ZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/
bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAoPUlEQVR4nO3df3DU9Z3H8deGkCUx7iaA2SWYYNoyUIXSaD
S3ivYPMgSPUVud9ppJKUeZMlg8wToUMw7UXscmhTt/
3SlqZ06ZqZWWGcHKiE6aUCLTGCAEELCRGymk6CZXYnaDQkjY9/3R43ssRgllQ/
JJn4+Z94z5ft673897SPKaTT5ufGZmAgDAUWlDvQEAAC4FQQYAcBpBBgBwGkEGAHAaQQYAcBpBBgBwGkEGA
HAaQQYAcBpBBgBwGkEGAHDasA6yp59+Wtdcc43GjBmj0tJS7dixY6i3BAAYZoZtkP3617/WD3/4Q/34xz/
W7t27NWPGDJWXl6ujo2OotwYAGEZ8w/VNg0tLS3XjjTfqP//zPyVJiURCBQUF+pd/
+Rc99NBDQ7w7AMBwkT7UG+jP6dOn1dzcrKqqKu9aWlqaysrK1NjY2O9jenp61NPT432cSCTU2dmpcePGyef
zDfqeAQCpY2bq7u5Wfn6+0tI+/4eHwzLI/vKXv+jMmTMKhUJJ10OhkP74xz/2+5jq6mr95Cc/
uRzbAwBcJm1tbbr66qs/t2fY/
o7sYlVVVSkWi3l19OjRod4SAOASXXnllRfsGZavyMaPH69Ro0apvb096Xp7e7vC4XC/j/H7/fL7/
ZdjewCAy2Qgvxoalq/IMjIydMMNN6iurs67lkgkVFdXp0gkMoQ7AwAMN8PyFZkk/
fCHP9T8+fNVUlKim266SU888YQ+/vhjLViwYKi3BgAYRoZtkP3TP/2T/ud//
kerVq1SNBrVV7/6Vb3xxhufOgACAPj7Nmz/P7JLFY/
HFQwGh3obAIBLEIvFFAgEPrdnWP6ODACAgSLIAABOI8gAAE4jyAAATiPIAABOI8gAAE4jyAAATiPIAABOI8
gAAE4jyAAATiPIAABOI8gAAE4jyAAATiPIAABOI8gAAE4jyAAATiPIAABOI8gAAE4jyAAATiPIAABOI8gAA
E4jyAAATiPIAABOI8gAAE4jyAAATiPIAABOI8gAAE4jyAAATiPIAABOI8gAAE4jyAAATiPIAABOI8gAAE4j
yAAATiPIAABOI8gAAE4jyAAATiPIAABOS3mQVVdX68Ybb9SVV16pvLw8ff3rX1dra2tSz6lTp7RkyRKNGzd
O2dnZuueee9Te3p7Uc/ToUc2dO1dZWVnKy8vT8uXL1dfXl+rtAgAcl/
Ig27Ztm5YsWaK3335btbW16u3t1ezZs/Xxxx97PQ888IBee+01bdiwQdu2bdMHH3ygu+++21s/
c+aM5s6dq9OnT+sPf/iD1q1bpxdffFGrVq1K9XYBAK6zQdbR0WGSbNu2bWZm1tXVZaNHj7YNGzZ4Pe++
+65JssbGRjMze/311y0tLc2i0ajXs3btWgsEAtbT0zOg+8ZiMZNEURRFOVyxWOyC3+8H/
XdksVhMkjR27FhJUnNzs3p7e1VWVub1TJ06VYWFhWpsbJQkNTY2avr06QqFQl5PeXm54vG4Dhw40O99enp6
FI/
HkwoAMPINapAlEgktW7ZMt9xyi6ZNmyZJikajysjIUE5OTlJvKBRSNBr1es4NsbPrZ9f6U11drWAw6FVBQU
GKpwEADEeDGmRLlizR/v37tX79+sG8jSSpqqpKsVjMq7a2tkG/
JwBg6KUP1hPfd9992rx5sxoaGnT11Vd718PhsE6fPq2urq6kV2Xt7e0Kh8Nez44dO5Ke7+ypxrM95/P7/
fL7/
SmeAgAw3KX8FZmZ6b777tPGjRtVX1+voqKipPUbbrhBo0ePVl1dnXettbVVR48eVSQSkSRFIhG988476ujo
8Hpqa2sVCAR07bXXpnrLAACXXcQBxAG59957LRgM2u9//3v78MMPvfrkk0+8nsWLF1thYaHV19fbrl27LBK
JWCQS8db7+vps2rRpNnv2bNuzZ4+98cYbdtVVV1lVVdWA98GpRYqiKPdrIKcWUx5kn7WZF154wes5efKk/
eAHP7Dc3FzLysqyb3zjG/bhhx8mPc+f/vQnu/322y0zM9PGjx9vDz74oPX29g54HwQZRVGU+zWQIPP9X/
iMOPF4XMFgcKi3AQC4BLFYTIFA4HN7eK9FAIDTCDIAgNMIMgCA0wgyAIDTCDIAgNMIMgCA0wgyAIDTCDIAg
NMIMgCA0wgyAIDTCDIAgNMIMgCA0wgyAIDTCDIAgNMIMgCA0wgyAIDTCDIAgNMIMgCA0wgyAIDTCDIAgNMI
MgCA0wgyAIDTCDIAgNMIMgCA0wgyAIDTCDIAgNMIMgCA0wgyAIDTCDIAgNMIMgCA0wgyAIDTCDIAgNMIMgC
A0wgyAIDTCDIAgNMIMgCA0wgyAIDTCDIAgNMIMgCA0wY9yGpqauTz+bRs2TLv2qlTp7RkyRKNGzdO2dnZuu
eee9Te3p70uKNHj2ru3LnKyspSXl6eli9frr6+vsHeLgDAMYMaZDt37tRzzz2nr3zlK0nXH3jgAb322mvas
GGDtm3bpg8++EB33323t37mzBnNnTtXp0+f1h/
+8AetW7dOL774olatWjWY2wUAuMgGSXd3t02ePNlqa2vta1/7mi1dutTMzLq6umz06NG2YcMGr/
fdd981SdbY2GhmZq+//
rqlpaVZNBr1etauXWuBQMB6enr6vd+pU6csFot51dbWZpIoiqIohysWi10wbwbtFdmSJUs0d+5clZWVJV1v
bm5Wb29v0vWpU6eqsLBQjY2NkqTGxkZNnz5doVDI6ykvL1c8HteBAwf6vV91dbWCwaBXBQUFgzAVAGC4GZQ
gW79+vXbv3q3q6upPrUWjUWVkZCgnJyfpeigUUjQa9XrODbGz62fX+lNVVaVYLOZVW1tbCiYBAAx36al+wr
a2Ni1dulS1tbUaM2ZMqp/+M/n9fvn9/st2PwDA8JDyV2TNzc3q6OjQ9ddfr/
T0dKWnp2vbtm166qmnlJ6erlAopNOnT6urqyvpce3t7QqHw5KkcDj8qVOMZz8+2wMAgDQIQTZr1iy988472
rNnj1clJSWqrKz0/
nv06NGqq6vzHtPa2qqjR48qEolIkiKRiN555x11dHR4PbW1tQoEArr22mtTvWUAgMsu4WDigJ17atHMbPHi
xVZYWGj19fW2a9cui0QiFolEvPW+vj6bNm2azZ492/bs2WNvvPGGXXXVVVZVVTXge8ZisSE/
bUNRFEVdWg3k1GLKf0c2EI8//rjS0tJ0zz33qKenR+Xl5XrmmWe89VGjRmnz5s269957FYlEdMUVV2j+/
Pn613/916HYLgBgGPOZmQ31JgZDPB5XMBgc6m0AAC5BLBZTIBD43B7eaxEA4DSCDADgNIIMAOA0ggwA4DSC
DADgNIIMAOA0ggwA4DSCDADgNIIMAOA0ggwA4DSCDADgNIIMAOA0ggwA4DSCDADgNIIMAOA0ggwA4DSCDAD
gNIIMAOA0ggwA4DSCDADgNIIMAOA0ggwA4DSCDADgNIIMAOA0ggwA4DSCDADgNIIMAOA0ggwA4DSCDADgNI
IMAOA0ggwA4DSCDADgNIIMAOA0ggwA4DSCDADgNIIMAOA0ggwA4DSCDADgtEEJsmPHjuk73/
mOxo0bp8zMTE2fPl27du3y1s1Mq1at0oQJE5SZmamysjIdOnQo6Tk6OztVWVmpQCCgnJwcLVy4UCdOnBiM7
QIAHJbyIPvoo490yy23aPTo0dqyZYsOHjyof//
3f1dubq7Xs3r1aj311FN69tln1dTUpCuuuELl5eU6deqU11NZWakDBw6otrZWmzdvVkNDgxYtWpTq7QIAXG
cptmLFCps5c+ZnricSCQuHw7ZmzRrvWldXl/
n9fnv55ZfNzOzgwYMmyXbu3On1bNmyxXw+nx07dmxA+4jFYiaJoiiKcrhisdgFv9+n/
BXZb3/7W5WUlOib3/ym8vLyVFxcrF/
84hfe+uHDhxWNRlVWVuZdCwaDKi0tVWNjoySpsbFROTk5Kikp8XrKysqUlpampqamfu/
b09OjeDyeVACAkS/lQfb+++9r7dq1mjx5st58803de++9uv/+
+7Vu3TpJUjQalSSFQqGkx4VCIW8tGo0qLy8vaT09PV1jx471es5XXV2tYDDoVUFBQapHAwAMQykPskQioeu
vv14/+9nPVFxcrEWLFun73/++nn322VTfKklVVZVisZhXbW1tg3o/
AMDwkPIgmzBhgq699tqka1/+8pd19OhRSVI4HJYktbe3J/W0t7d7a+FwWB0dHUnrfX196uzs9HrO5/
f7FQgEkgoAMPKlPMhuueUWtba2Jl177733NGnSJElSUVGRwuGw6urqvPV4PK6mpiZFIhFJUiQSUVdXl5qbm
72e+vp6JRIJlZaWpnrLAACXDegI4EXYsWOHpaen26OPPmqHDh2yl156ybKysuyXv/
yl11NTU2M5OTn26quv2r59+
+yuu+6yoqIiO3nypNczZ84cKy4utqamJtu+fbtNnjzZKioqBrwPTi1SFEW5XwM5tZjyIDMze+2112zatGnm
9/tt6tSp9vzzzyetJxIJW7lypYVCIfP7/TZr1ixrbW1N6jl+/
LhVVFRYdna2BQIBW7BggXV3dw94DwQZRVGU+zWQIPOZmWkEisfjCgaDQ70NAMAliMViFzzzwHstAgCcRpAB
AJxGkAEAnEaQAQCcRpABAJxGkAEAnEaQAQCcRpABAJxGkAEAnEaQAQCcRpABAJxGkAEAnEaQAQCcRpABAJx
GkAEAnEaQAQCcRpABAJxGkAEAnEaQAQCcRpABAJxGkAEAnEaQAQCcRpABAJxGkAEAnEaQAQCcRpABAJxGkA
EAnEaQAQCcRpABAJxGkAEAnEaQAQCcRpABAJxGkAEAnEaQAQCcRpABAJxGkAEAnEaQAQCcRpABAJyW8iA7c
+aMVq5cqaKiImVmZuqLX/
yifvrTn8rMvB4z06pVqzRhwgRlZmaqrKxMhw4dSnqezs5OVVZWKhAIKCcnRwsXLtSJEydSvV0AgOssxR599
FEbN26cbd682Q4fPmwbNmyw7Oxse/LJJ72empoaCwaDtmnTJtu7d6/
deeedVlRUZCdPnvR65syZYzNmzLC3337b3nrrLfvSl75kFRUVA95HLBYzSRRFUZTDFYvFLvj9PuVBNnfuXP
ve976XdO3uu++2yspKMzNLJBIWDodtzZo13npXV5f5/
X57+eWXzczs4MGDJsl27tzp9WzZssV8Pp8dO3ZsQPsgyCiKotyvgQRZyn+0ePPNN6uurk7vvfeeJGnv3r3a
vn27br/9dknS4cOHFY1GVVZW5j0mGAyqtLRUjY2NkqTGxkbl5OSopKTE6ykrK1NaWpqampr6vW9PT4/
i8XhSAQBGvvRUP+FDDz2keDyuqVOnatSoUTpz5oweffRRVVZWSpKi0agkKRQKJT0uFAp5a9FoVHl5eckbTU
/X2LFjvZ7zVVdX6yc/+UmqxwEADHMpf0X2m9/8Ri+99JJ+9atfaffu3Vq3bp3+7d/
+TevWrUv1rZJUVVUpFot51dbWNqj3AwAMDyl/
RbZ8+XI99NBD+va3vy1Jmj59uo4cOaLq6mrNnz9f4XBYktTe3q4JEyZ4j2tvb9dXv/pVSVI4HFZHR0fS8/
b19amzs9N7/Pn8fr/8fn+qxwEADHMpf0X2ySefKC0t+WlHjRqlRCIhSSoqKlI4HFZdXZ23Ho/
H1dTUpEgkIkmKRCLq6upSc3Oz11NfX69EIqHS0tJUbxkA4LIBHQG8CPPnz7eJEyd6x+9feeUVGz9+vP3oRz
/
yempqaiwnJ8deffVV27dvn9111139Hr8vLi62pqYm2759u02ePJnj9xRFUX9nNSTH7+PxuC1dutQKCwttzJ
gx9oUvfMEefvhh6+np8XoSiYStXLnSQqGQ+f1+mzVrlrW2tiY9z/
Hjx62iosKys7MtEAjYggULrLu7e8D7IMgoiqLcr4EEmc/
snLfcGEHi8biCweBQbwMAcAlisZgCgcDn9vBeiwAApxFkAACnEWQAAKcRZAAApxFkAACnEWQAAKcRZAAApx
FkAACnEWQAAKcRZAAApxFkAACnEWQAAKcRZAAApxFkAACnEWQAAKcRZAAApxFkAACnEWQAAKcRZAAApxFkA
ACnEWQAAKcRZAAApxFkAACnEWQAAKcRZAAApxFkAACnEWQAAKcRZAAApxFkAACnEWQAAKcRZAAApxFkAACn
EWQAAKcRZAAApxFkAACnEWQAAKcRZAAApxFkAACnXXSQNTQ06I477lB+fr58Pp82bdqUtG5mWrVqlSZMmKD
MzEyVlZXp0KFDST2dnZ2qrKxUIBBQTk6OFi5cqBMnTiT17Nu3T7feeqvGjBmjgoICrV69+uKnAwCMeBcdZB
9//LFmzJihp59+ut/
11atX66mnntKzzz6rpqYmXXHFFSovL9epU6e8nsrKSh04cEC1tbXavHmzGhoatGjRIm89Ho9r9uzZmjRpkp
qbm7VmzRo98sgjev755/+GEQEAI5pdAkm2ceNG7+NEImHhcNjWrFnjXevq6jK/328vv/
yymZkdPHjQJNnOnTu9ni1btpjP57Njx46Zmdkzzzxjubm51tPT4/
WsWLHCpkyZMuC9xWIxk0RRFEU5XLFY7ILf71P6O7LDhw8rGo2qrKzMuxYMBlVaWqrGxkZJUmNjo3JyclRSU
uL1lJWVKS0tTU1NTV7PbbfdpoyMDK+nvLxcra2t+uijj/
q9d09Pj+LxeFIBAEa+lAZZNBqVJIVCoaTroVDIW4tGo8rLy0taT09P19ixY5N6+nuOc+9xvurqagWDQa8KC
goufSAAwLA3Yk4tVlVVKRaLedXW1jbUWwIAXAYpDbJwOCxJam9vT7re3t7urYXDYXV0dCSt9/
X1qbOzM6mnv+c49x7n8/
v9CgQCSQUAGPlSGmRFRUUKh8Oqq6vzrsXjcTU1NSkSiUiSIpGIurq61Nzc7PXU19crkUiotLTU62loaFBvb
6/XU1tbqylTpig3NzeVWwYAuG7AxwD/
T3d3t7W0tFhLS4tJsscee8xaWlrsyJEjZmZWU1NjOTk59uqrr9q+ffvsrrvusqKiIjt58qT3HHPmzLHi4mJ
ramqy7du32+TJk62iosJb7+rqslAoZPPmzbP9+/
fb+vXrLSsry5577rkB75NTixRFUe7XQE4tXnSQbd26td+bzZ8/38z+egR/5cqVFgqFzO/
326xZs6y1tTXpOY4fP24VFRWWnZ1tgUDAFixYYN3d3Uk9e/futZkzZ5rf77eJEydaTU3NRe2TIKMoinK/
BhJkPjMzjUDxeFzBYHCotwEAuASxWOyCZx5GzKlFAMDfJ4IMAOA0ggwA4DSCDADgNIIMAOA0ggwA4DSCDAD
gNIIMAOA0ggwA4DSCDADgNIIMAOA0ggwA4DSCDADgNIIMAOA0ggwA4DSCDADgNIIMAOA0ggwA4DSCDADgNI
IMAOA0ggwA4DSCDADgNIIMAOA0ggwA4DSCDADgNIIMAOA0ggwA4DSCDADgNIIMAOA0ggwA4DSCDADgNIIMA
OA0ggwA4DSCDADgNIIMAOA0ggwA4DSCDADgNIIMAOA0ggwA4LSLDrKGhgbdcccdys/Pl8/
n06ZNm7y13t5erVixQtOnT9cVV1yh/
Px8ffe739UHH3yQ9BydnZ2qrKxUIBBQTk6OFi5cqBMnTiT17Nu3T7feeqvGjBmjgoICrV69+m+bEAAwol10
kH388ceaMWOGnn766U+tffLJJ9q9e7dWrlyp3bt365VXXlFra6vuvPPOpL7KykodOHBAtbW12rx5sxoaGrR
o0SJvPR6Pa/bs2Zo0aZKam5u1Zs0aPfLII3r++ef/hhEBACOaXQJJtnHjxs/
t2bFjh0myI0eOmJnZwYMHTZLt3LnT69myZYv5fD47duyYmZk988wzlpubaz09PV7PihUrbMqUKZ95n1OnTl
ksFvOqra3NJFEURVEOVywWu2AWDfrvyGKxmHw+n3JyciRJjY2NysnJUUlJiddTVlamtLQ0NTU1eT233XabM
jIyvJ7y8nK1trbqo48+6vc+1dXVCgaDXhUUFAzeUACAYWNQg+zUqVNasWKFKioqFAgEJEnRaFR5eXlJfenp
6Ro7dqyi0ajXEwqFknrOfny253xVVVWKxWJetbW1pXocAMAwlD5YT9zb26tvfetbMjOtXbt2sG7j8fv98vv
9g34fAMDwMihBdjbEjhw5ovr6eu/VmCSFw2F1dHQk9ff19amzs1PhcNjraW9vT+o5+/
HZHgAApEH40eLZEDt06JB+97vfady4cUnrkUhEXV1dam5u9q7V19crkUiotLTU62loaFBvb6/
XU1tbqylTpig3NzfVWwYAuOyCx0HO093dbS0tLdbS0mKS7LHHHrOWlhY7cuSInT592u688067+uqrbc+ePf
bhhx96de4JxDlz5lhxcbE1NTXZ9u3bbfLkyVZRUeGtd3V1WSgUsnnz5tn+/ftt/
fr1lpWVZc8999yA9xmLxYb8tA1FURR1aTWQU4sXHWRbt27t92bz58+3w4cPf+Zmtm7d6j3H8ePHraKiwrKz
sy0QCNiCBQusu7s76T579+61mTNnmt/
vt4kTJ1pNTc1F7ZMgoyiKcr8GEmQ+MzONQPF4XMFgcKi3AQC4BLFYLOmcRX94r0UAgNMIMgCA0wgyAIDTCD
IAgNMIMgCA0wgyAIDTCDIAgNMIMgCA0wgyAIDTCDIAgNMIMgCA0wgyAIDTCDIAgNMIMgCA0wgyAIDTCDIAg
NMIMgCA0wgyAIDTCDIAgNMIMgCA0wgyAIDTCDIAgNMIMgCA0wgyAIDTCDIAgNMIMgCA0wgyAIDTCDIAgNMI
MgCA0wgyAIDTCDIAgNMIMgCA0wgyAIDTCDIAgNMIMgCA0wgyAIDTCDIAgNMIMgCA0y46yBoaGnTHHXcoPz9
fPp9PmzZt+szexYsXy+fz6Yknnki63tnZqcrKSgUCAeXk5GjhwoU6ceJEUs+
+fft06623asyYMSooKNDq1asvdqsAgL8DFx1kH3/8sWbMmKGnn376c/s2btyot99+W/
n5+Z9aq6ys1IEDB1RbW6vNmzeroaFBixYt8tbj8bhmz56tSZMmqbm5WWvWrNEjjzyi559//
mK3CwAY6ewSSLKNGzd+6vqf//xnmzhxou3fv98mTZpkjz/
+uLd28OBBk2Q7d+70rm3ZssV8Pp8dO3bMzMyeeeYZy83NtZ6eHq9nxYoVNmXKlAHvLRaLmSSKoijK4YrFYh
f8fp/
y35ElEgnNmzdPy5cv13XXXfep9cbGRuXk5KikpMS7VlZWprS0NDU1NXk9t912mzIyMrye8vJytba26qOPPu
r3vj09PYrH40kFABj5Uh5kP//5z5Wenq7777+/3/
VoNKq8vLyka+np6Ro7dqyi0ajXEwqFknrOfny253zV1dUKBoNeFRQUXOooAAAHpDTImpub9eSTT+rFF1+Uz
+dL5VNfUFVVlWKxmFdtbW2X9f4AgKGR0iB766231NHRocLCQqWnpys9PV1HjhzRgw8+qGuuuUaSFA6H1dHR
kfS4vr4+dXZ2KhwOez3t7e1JPWc/PttzPr/
fr0AgkFQAgJEvpUE2b9487du3T3v27PEqPz9fy5cv15tvvilJikQi6urqUnNzs/
e4+vp6JRIJlZaWej0NDQ3q7e31emprazVlyhTl5uamcssAANcN+Bjg/
+nu7raWlhZraWkxSfbYY49ZS0uLHTlypN/
+808tmpnNmTPHiouLrampybZv326TJ0+2iooKb72rq8tCoZDNmzfP9u/
fb+vXr7esrCx77rnnBrxPTi1SFEW5XwM5tXjRQbZ169Z+bzZ//vx++/sLsuPHj1tFR
YVlZ2dbIBCwBQsWWHd3d1LP3r17bebMmeb3+23ixIlWU1NzUfskyCiKotyvgQSZz8xMI1A8HlcwGBzqbQAA
LkEsFrvgmQfeaxEA4DSCDADgNIIMAOA0ggwA4DSCDADgNIIMAOA0ggwA4DSCDADgNIIMAOA0ggwA4DSCDAD
gNIIMAOA0ggwA4DSCDADgNIIMAOA0ggwA4LQRG2Qj9O+FAsDflYF8Lx+xQXb8+PGh3gIA4BJ1d3dfsCf9Mu
xjSIwdO1aSdPToUQWDwSHezd8mHo+roKBAbW1tF/xT38PZSJiDGYaHkTCDNDLmGOwZzEzd3d3Kz8+/
YO+IDbK0tL++2AwGg85+opwVCAScn0EaGXMww/AwEmaQRsYcgznDQF+EjNgfLQIA/j4QZAAAp43YIPP7/
frxj38sv98/1Fv5m42EGaSRMQczDA8jYQZpZMwxnGbwGefUAQAOG7GvyAAAfx8IMgCA0wgyAIDTCDIAgNMI
MgCA00ZkkD399NO65pprNGbMGJWWlmrHjh1DvSVPdXW1brzxRl155ZXKy8vT17/+dbW2tib1nDp1SkuWLNG
4ceOUnZ2te+65R+3t7Uk9R48e1dy5c5WVlaW8vDwtX75cfX19l3MUT01NjXw+n5YtW+Zdc2WGY8eO6Tvf+Y
7GjRunzMxMTZ8+Xbt27fLWzUyrVq3ShAkTlJmZqbKyMh06dCjpOTo7O1VZWalAIKCcnBwtXLhQJ06cuCz7P
3PmjFauXKmioiJlZmbqi1/8on76058mvdHqcJuhoaFBd9xxh/Lz8+Xz+bRp06ak9VTtd9+
+fbr11ls1ZswYFRQUaPXq1Zdtjt7eXq1YsULTp0/XFVdcofz8fH33u9/VBx98MKzmuNC/
xbkWL14sn8+nJ554YljNIEmyEWb9+vWWkZFh//Vf/
2UHDhyw73//+5aTk2Pt7e1DvTUzMysvL7cXXnjB9u/fb3v27LF//Md/
tMLCQjtx4oTXs3jxYisoKLC6ujrbtWuX/cM//IPdfPPN3npfX59NmzbNysrKrKWlxV5//
XUbP368VVVVXfZ5duzYYddcc4195StfsaVLlzo1Q2dnp02aNMn++Z//2Zqamuz999+3N9980/77v//
b66mpqbFgMGibNm2yvXv32p133mlFRUV28uRJr2fOnDk2Y8YMe/
vtt+2tt96yL33pS1ZRUXFZZnj00Udt3LhxtnnzZjt8+LBt2LDBsrOz7cknnxy2M7z+
+uv28MMP2yuvvGKSbOPGjUnrqdhvLBazUChklZWVtn//fnv55ZctMzPTnnvuucsyR1dXl5WVldmvf/1r+
+Mf/2iNjY1200032Q033JD0HEM9x4X+Lc565ZVXbMaMGZafn2+PP/
74sJrBzGzEBdlNN91kS5Ys8T4+c+aM5efnW3V19RDu6rN1dHSYJNu2bZuZ/
fULYPTo0bZhwwav59133zVJ1tjYaGZ//
eRLS0uzaDTq9axdu9YCgYD19PRctr13d3fb5MmTrba21r72ta95QebKDCtWrLCZM2d+5noikbBwOGxr1qzx
rnV1dZnf77eXX37ZzMwOHjxokmznzp1ez5YtW8zn89mxY8cGb/P/Z+7cufa9730v6drdd99tlZWVTsxw/
jfPVO33mWeesdzc3KTPpRUrVtiUKVMuyxz92bFjh0myI0eOmNnwm+OzZvjzn/
9sEydOtP3799ukSZOSgmy4zDCifrR4+vRpNTc3q6yszLuWlpamsrIyNTY2DuHOPlssFpP0/+/
W39zcrN7e3qQZpk6dqsLCQm+GxsZGTZ8+XaFQyOspLy9XPB7XgQMHLtvelyxZorlz5ybtVXJnht/
+9rcqKSnRN7/5TeXl5am4uFi/
+MUvvPXDhw8rGo0mzREMBlVaWpo0R05OjkpKSryesrIypaWlqampadBnuPnmm1VXV6f33ntPkrR3715t375
dt99+uzMznCtV+21sbNRtt92mjIwMr6e8vFytra366KOPLtM0yWKxmHw+n3Jycrw9Dvc5EomE5s2bp+XLl+
u666771PpwmWFEBdlf/
vIXnTlzJumboySFQiFFo9Eh2tVnSyQSWrZsmW655RZNmzZNkhSNRpWRkeF9sp917gzRaLTfGc+uXQ7r16/
X7t27VV1d/ak1V2Z4//33tXbtWk2ePFlvvvmm7r33Xt1///1at25d0j4+7/
MpGo0qLy8vaT09PV1jx469LHM89NBD+va3v62pU6dq9OjRKi4u1rJly1RZWenMDOdK1X6Hw+fXuU6dOqUVK
1aooqLCe6d4F+b4+c9/rvT0dN1///39rg+XGUbsn3FxwZIlS7R//
35t3759qLdyUdra2rR06VLV1tZqzJgxQ72dv1kikVBJSYl+9rOfSZKKi4u1f/9+Pfvss5o/f/
4Q725gfvOb3+ill17Sr371K1133XXas2ePli1bpvz8fGdmGOl6e3v1rW99S2amtWvXDvV2Bqy5uVlPPvmkd
u/eLZ/
PN9Tb+Vwj6hXZ+PHjNWrUqE+djmtvb1c4HB6iXfXvvvvu0+bNm7V161ZdffXV3vVwOKzTp0+rq6srqf/
cGcLhcL8znl0bbM3Nzero6ND111+v9PR0paena9u2bXrqqaeUnp6uUCg07GeQpAkTJujaa69NuvblL39ZR4
8eTdrH530+hcNhdXR0JK339fWps7PzssyxfPly71XZ9OnTNW/ePD3wwAPeK2UXZjhXqvY7HD6/
pP8PsSNHjqi2tjbp73YN9zneeustdXR0qLCw0Ps6P3LkiB588EFdc801w2qGERVkGRkZuuGGG1RXV+ddSyQ
SqqurUyQSGcKd/
T8z03333aeNGzeqvr5eRUVFSes33HCDRo8enTRDa2urjh496s0QiUT0zjvvJH0Cnf0iOf8b82CYNWuW3nnn
He3Zs8erkpISVVZWev893GeQpFtuueVT/+vDe+
+9p0mTJkmSioqKFA6Hk+aIx+NqampKmqOrq0vNzc1eT319vRKJhEpLSwd9hk8+
+cT7I7JnjRo1SolEwpkZzpWq/
UYiETU0NKi3t9frqa2t1ZQpU5Sbm3tZZjkbYocOHdLvfvc7jRs3Lml9uM8xb9487du3L+nrPD8/
X8uXL9ebb745vGZI2bGRYWL9+vXm9/vtxRdftIMHD9qiRYssJycn6XTcULr33nstGAza73//e/
vwww+9+uSTT7yexYsXW2FhodXX19uuXbssEolYJBLx1s8eXZ89e7bt2bPH3njjDbvqqquG5Pj9WeeeWjRzY
4YdO3ZYenq6Pfroo3bo0CF76aWXLCsry375y196PTU1NZaTk2Ovvvqq7du3z+66665+j4IXFxdbU1OTbd+
+3SZPnnzZjt/Pnz/fJk6c6B2/f+WVV2z8+PH2ox/
9aNjO0N3dbS0tLdbS0mKS7LHHHrOWlhbvNF8q9tvV1WWhUMjmzZtn+/fvt/Xr11tWVlZKj3x/3hynT5+2O+
+8066++mrbs2dP0tf6uaf3hnqOC/1bnO/8U4vDYQazEXj83szsP/
7jP6ywsNAyMjLspptusrfffnuot+SR1G+98MILXs/JkyftBz/4geXm5lpWVpZ94xvfsA8//DDpef70pz/
Z7bffbpmZmTZ+/Hh78MEHrbe39zJP8//
ODzJXZnjttdds2rRp5vf7berUqfb8888nrScSCVu5cqWFQiHz+/
02a9Ysa21tTeo5fvy4VVRUWHZ2tgUCAVuwYIF1d3dflv3H43FbunSpFRYW2pgxY+wLX/
iCPfzww0nfLIfbDFu3bu33a2D+/Pkp3e/
evXtt5syZ5vf7beLEiVZTU3PZ5jh8+PBnfq1v3bp12MxxoX+L8/
UXZEM9g5kZf48MAOC0EfU7MgDA3x+CDADgNIIMAOA0ggwA4DSCDADgNIIMAOA0ggwA4DSCDADgNIIMAOA0g
gwA4DSCDADgtP8FwPeruHk+YigAAAAASUVORK5CYII=\n"
},
"metadata": {}
}
]
},
{
"cell_type": "code",
"source": [
"resnet50=torchvision.models.resnet50(pretrained=True)\n"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "o16ymZ-1Uqcz",
"outputId": "32df2a85-d328-479d-f8fa-0d85de9c4523"
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stderr",
"text": [

"/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:208:
UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed
in the future, please use 'weights' instead.\n",
" warnings.warn(\n",

"/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:223:
UserWarning: Arguments other than a weight enum or `None` for 'weights' are
deprecated since 0.13 and may be removed in the future. The current behavior is
equivalent to passing `weights=ResNet50_Weights.IMAGENET1K_V1`. You can also use
`weights=ResNet50_Weights.DEFAULT` to get the most up-to-date weights.\n",
 " warnings.warn(msg)\n"
]
}
]
},
{
"cell_type": "code",
"source": [
"class modell(nn.Module):\n",
" def __init__(self):\n",
" super().__init__()\n",
" self.resnet50=resnet50\n",
" self.fc=nn.Linear(1000,3)\n",
" def forward(self,x):\n",
" x=self.resnet50(x)\n",
" x=self.fc(x)\n",
" x=torch.sigmoid(x)\n",
" return x\n"
],
"metadata": {
"id": "mDQfahhJU3tB"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"#training loop\n",
"model=modell()\n",
"criterion=nn.SmoothL1Loss()\n",
"optimizer=optim.Adam(model.parameters(),lr=0.001)\n",
"#freeze params\n",
"model.resnet50.requires_grad_(False)\n",
"epochs=5000\n",
"losses=[]\n",
"for epoch in range(epochs):\n",
" for i in range(len(resnetimages)):\n",
" optimizer.zero_grad()\n",
" equis=resnetimages[i].unsqueeze(0)\n",
" output=model(equis)\n",
" print(output.shape)\n",
" output0angle=output[0,0]*np.pi\n",
" output1vel=output[0,1]*1500\n",
" bias=output[0,2]*1500\n",
" vyhat=torch.sin(output0angle)*output1vel\n",
" posin5seconds=bias+vyhat*5+(1/2)*9.8*5**2\n",
" loss=criterion(posin5seconds,torch.tensor(ys[i]))\n",
" losses.append(loss.item())\n",
" plt.plot(losses)\n",
"
print({\"loss\":loss,\"posin5seconds\":posin5seconds,\"output\":output,\"y\":ys[i]}
)\n",
" loss.backward()\n",
" optimizer.step()"
],
"metadata": {
"id": "u_i6qStZVLVU",
"colab": {
 "base_uri": "https://localhost:8080/",
"height": 1000
},
"outputId": "03a77ad9-00bd-4065-8335-4324358380e8"
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"\u001b[1;30;43mSe truncaron las últimas líneas 5000 del resultado de
transmisión.\u001b[0m\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(147.2468, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1115.2468, grad_fn=<AddBackward0>), 'output':
tensor([[0.0036, 0.0048, 0.6616]], grad_fn=<SigmoidBackward0>), 'y': 967.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(50.2067, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(575.2067, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0048, 0.3015]], grad_fn=<SigmoidBackward0>), 'y': 524.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(234.5709, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(386.5709, grad_fn=<AddBackward0>), 'output':
tensor([[0.0040, 0.0053, 0.1757]], grad_fn=<SigmoidBackward0>), 'y': 151.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(124.7078, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1085.7078, grad_fn=<AddBackward0>), 'output':
tensor([[0.0038, 0.0051, 0.6418]], grad_fn=<SigmoidBackward0>), 'y': 960.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(77.2131, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(987.7869, grad_fn=<AddBackward0>), 'output':
tensor([[0.0036, 0.0050, 0.5766]], grad_fn=<SigmoidBackward0>), 'y': 1065.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(153.8535, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(297.8535, grad_fn=<AddBackward0>), 'output':
tensor([[0.0038, 0.0050, 0.1166]], grad_fn=<SigmoidBackward0>), 'y': 143.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(88.1500, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(606.8500, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0044, 0.3227]], grad_fn=<SigmoidBackward0>), 'y': 695.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(151.2036, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(759.7964, grad_fn=<AddBackward0>), 'output':
tensor([[0.0035, 0.0047, 0.4246]], grad_fn=<SigmoidBackward0>), 'y': 911.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(117.4084, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(801.5916, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0044, 0.4525]], grad_fn=<SigmoidBackward0>), 'y': 919.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(125.1273, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(935.8727, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0047, 0.5420]], grad_fn=<SigmoidBackward0>), 'y': 1061.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(55.4551, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(342.4551, grad_fn=<AddBackward0>), 'output':
tensor([[0.0035, 0.0051, 0.1464]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(159.6311, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1100.6311, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0044, 0.6519]], grad_fn=<SigmoidBackward0>), 'y': 940.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(418.2310, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(546.2310, grad_fn=<AddBackward0>), 'output':
tensor([[0.0038, 0.0049, 0.2822]], grad_fn=<SigmoidBackward0>), 'y':
127.50000000000001}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(64.1564, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(981.1564, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0045, 0.5722]], grad_fn=<SigmoidBackward0>), 'y': 916.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(37.1837, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(350.1837, grad_fn=<AddBackward0>), 'output':
tensor([[0.0037, 0.0051, 0.1515]], grad_fn=<SigmoidBackward0>), 'y': 312.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(53.5702, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(454.4298, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0047, 0.2210]], grad_fn=<SigmoidBackward0>), 'y': 508.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(74.4346, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(435.5654, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0046, 0.2085]], grad_fn=<SigmoidBackward0>), 'y': 510.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(75.2966, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(465.2966, grad_fn=<AddBackward0>), 'output':
tensor([[0.0035, 0.0049, 0.2283]], grad_fn=<SigmoidBackward0>), 'y': 389.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(191.9922, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(344.9922, grad_fn=<AddBackward0>), 'output':
tensor([[0.0038, 0.0051, 0.1480]], grad_fn=<SigmoidBackward0>), 'y': 152.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.2614, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(388.2614, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0046, 0.1769]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(65.1891, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(396.8109, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0043, 0.1827]], grad_fn=<SigmoidBackward0>), 'y': 462.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(63.5493, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(548.4507, grad_fn=<AddBackward0>), 'output':
tensor([[0.0035, 0.0046, 0.2837]], grad_fn=<SigmoidBackward0>), 'y': 612.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(113.0126, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(627.9874, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0039, 0.3368]], grad_fn=<SigmoidBackward0>), 'y': 741.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(119.5319, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(744.4681, grad_fn=<AddBackward0>), 'output':
tensor([[0.0038, 0.0053, 0.4143]], grad_fn=<SigmoidBackward0>), 'y': 864.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(59.7385, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(957.7385, grad_fn=<AddBackward0>), 'output':
tensor([[0.0035, 0.0048, 0.5566]], grad_fn=<SigmoidBackward0>), 'y': 897.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(128.4222, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(461.5778, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0047, 0.2258]], grad_fn=<SigmoidBackward0>), 'y': 590.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(5.6229, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1023.3771, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0042, 0.6004]], grad_fn=<SigmoidBackward0>), 'y': 1029.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(203.4514, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(917.5486, grad_fn=<AddBackward0>), 'output':
tensor([[0.0035, 0.0049, 0.5298]], grad_fn=<SigmoidBackward0>), 'y': 1121.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(25.4271, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(535.5729, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0042, 0.2752]], grad_fn=<SigmoidBackward0>), 'y': 561.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(126.4792, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(952.4792, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0047, 0.5531]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(304.6243, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(518.6243, grad_fn=<AddBackward0>), 'output':
tensor([[0.0037, 0.0051, 0.2638]], grad_fn=<SigmoidBackward0>), 'y': 213.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(68.3704, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(632.3704, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0042, 0.3397]], grad_fn=<SigmoidBackward0>), 'y': 563.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(228.3645, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1135.3645, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0045, 0.6750]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(191.0416, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1280.0416, grad_fn=<AddBackward0>), 'output':
tensor([[0.0035, 0.0047, 0.7714]], grad_fn=<SigmoidBackward0>), 'y': 1088.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(155.7822, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1148.7822, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0043, 0.6840]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(145.5616, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(384.5616, grad_fn=<AddBackward0>), 'output':
tensor([[0.0037, 0.0049, 0.1744]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.9502, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1055.0498, grad_fn=<AddBackward0>), 'output':
tensor([[0.0036, 0.0049, 0.6214]], grad_fn=<SigmoidBackward0>), 'y': 1074.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(14.4164, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(522.4164, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0044, 0.2664]], grad_fn=<SigmoidBackward0>), 'y': 507.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(117.4948, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(267.4948, grad_fn=<AddBackward0>), 'output':
tensor([[0.0038, 0.0051, 0.0964]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(83.5782, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(821.5782, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0040, 0.4659]], grad_fn=<SigmoidBackward0>), 'y': 737.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(22.3960, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(246.3960, grad_fn=<AddBackward0>), 'output':
tensor([[0.0037, 0.0046, 0.0823]], grad_fn=<SigmoidBackward0>), 'y': 223.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(123.6520, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(813.3480, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0042, 0.4604]], grad_fn=<SigmoidBackward0>), 'y': 937.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(196.3458, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(632.6542, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0043, 0.3399]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(73.0185, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(271.9815, grad_fn=<AddBackward0>), 'output':
tensor([[0.0035, 0.0049, 0.0994]], grad_fn=<SigmoidBackward0>), 'y': 345.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(118.5752, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(738.4248, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0046, 0.4104]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(202.5451, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(411.4549, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0045, 0.1924]], grad_fn=<SigmoidBackward0>), 'y': 614.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.3517, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(285.3517, grad_fn=<AddBackward0>), 'output':
tensor([[0.0036, 0.0049, 0.1083]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(172.1785, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(325.8215, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0049, 0.1353]], grad_fn=<SigmoidBackward0>), 'y': 498.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(43.1976, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(267.8024, grad_fn=<AddBackward0>), 'output':
tensor([[0.0036, 0.0052, 0.0966]], grad_fn=<SigmoidBackward0>), 'y': 311.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(53.4651, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(282.4651, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0046, 0.1064]], grad_fn=<SigmoidBackward0>), 'y': 228.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(142.7725, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(299.2275, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0044, 0.1176]], grad_fn=<SigmoidBackward0>), 'y': 442.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(66.4214, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(345.4214, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0045, 0.1484]], grad_fn=<SigmoidBackward0>), 'y': 278.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(2.4734, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(403.5266, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0044, 0.1871]], grad_fn=<SigmoidBackward0>), 'y': 406.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(65.6035, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1085.6035, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.6419]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(102.8837, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(391.1163, grad_fn=<AddBackward0>), 'output':
tensor([[0.0037, 0.0050, 0.1788]], grad_fn=<SigmoidBackward0>), 'y': 494.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(60.8274, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1042.8274, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0042, 0.6134]], grad_fn=<SigmoidBackward0>), 'y': 981.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.5964, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(721.5964, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0041, 0.3992]], grad_fn=<SigmoidBackward0>), 'y': 707.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(67.4460, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(285.4460, grad_fn=<AddBackward0>), 'output':
tensor([[0.0040, 0.0053, 0.1083]], grad_fn=<SigmoidBackward0>), 'y': 217.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(114.7010, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(791.2990, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0045, 0.4456]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(9.4694, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(882.4694, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0047, 0.5064]], grad_fn=<SigmoidBackward0>), 'y': 872.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(203.4195, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(855.5805, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0046, 0.4885]], grad_fn=<SigmoidBackward0>), 'y': 1059.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.1182, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(328.9863, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0047, 0.1374]], grad_fn=<SigmoidBackward0>), 'y': 328.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(34.3481, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(635.6519, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0043, 0.3419]], grad_fn=<SigmoidBackward0>), 'y': 670.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(50.5471, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(526.4529, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0050, 0.2690]], grad_fn=<SigmoidBackward0>), 'y': 577.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.1799, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(342.1799, grad_fn=<AddBackward0>), 'output':
tensor([[0.0035, 0.0050, 0.1462]], grad_fn=<SigmoidBackward0>), 'y': 302.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(28.7542, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(520.2458, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0042, 0.2650]], grad_fn=<SigmoidBackward0>), 'y': 549.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(55.3408, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(314.3408, grad_fn=<AddBackward0>), 'output':
tensor([[0.0035, 0.0050, 0.1276]], grad_fn=<SigmoidBackward0>), 'y': 258.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(133.8486, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(302.8486, grad_fn=<AddBackward0>), 'output':
tensor([[0.0040, 0.0051, 0.1199]], grad_fn=<SigmoidBackward0>), 'y': 168.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(33.0009, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(640.9991, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0044, 0.3454]], grad_fn=<SigmoidBackward0>), 'y': 674.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(15.8530, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1032.8530, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0044, 0.6067]], grad_fn=<SigmoidBackward0>), 'y': 1016.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(41.8400, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(783.1600, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0047, 0.4402]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(95.7509, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(740.7509, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0042, 0.4120]], grad_fn=<SigmoidBackward0>), 'y': 644.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(262.5897, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1284.5897, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.7746]], grad_fn=<SigmoidBackward0>), 'y': 1021.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(72.8574, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(553.8574, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0042, 0.2874]], grad_fn=<SigmoidBackward0>), 'y': 480.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(64.5710, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1035.5710, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0047, 0.6085]], grad_fn=<SigmoidBackward0>), 'y': 970.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(54.6162, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1078.6162, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0035, 0.6373]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(217.9812, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(350.0188, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0047, 0.1514]], grad_fn=<SigmoidBackward0>), 'y': 568.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(204.7195, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(606.2805, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0042, 0.3223]], grad_fn=<SigmoidBackward0>), 'y': 811.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(171.1563, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(358.8437, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0045, 0.1573]], grad_fn=<SigmoidBackward0>), 'y': 530.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(170.5683, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(752.4317, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0043, 0.4198]], grad_fn=<SigmoidBackward0>), 'y': 923.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(233.0762, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(405.9238, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0042, 0.1888]], grad_fn=<SigmoidBackward0>), 'y': 639.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.5525, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(285.4475, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0047, 0.1084]], grad_fn=<SigmoidBackward0>), 'y': 290.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(119.6721, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(513.3279, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0043, 0.2603]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(139.8831, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(348.1169, grad_fn=<AddBackward0>), 'output':
tensor([[0.0035, 0.0048, 0.1502]], grad_fn=<SigmoidBackward0>), 'y': 488.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(25.7490, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(765.2510, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0043, 0.4283]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(169.6196, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1024.6196, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0044, 0.6012]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.6296, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1011.6296, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0043, 0.5925]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(216.0685, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1156.0685, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0041, 0.6888]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(120.4593, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(728.4593, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0047, 0.4037]], grad_fn=<SigmoidBackward0>), 'y': 607.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(194.1349, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1054.1349, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0045, 0.6209]], grad_fn=<SigmoidBackward0>), 'y': 859.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(125.5392, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1059.5392, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0039, 0.6245]], grad_fn=<SigmoidBackward0>), 'y': 933.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(26.0521, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(802.9479, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0044, 0.4534]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(32.9525, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(790.0475, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0046, 0.4448]], grad_fn=<SigmoidBackward0>), 'y': 823.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(152.2411, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(465.7589, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0044, 0.2286]], grad_fn=<SigmoidBackward0>), 'y': 618.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(117.3341, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(422.6659, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0046, 0.1999]], grad_fn=<SigmoidBackward0>), 'y': 540.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(6.8852, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(831.1148, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0039, 0.4722]], grad_fn=<SigmoidBackward0>), 'y': 838.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(115.4722, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(364.4722, grad_fn=<AddBackward0>), 'output':
tensor([[0.0036, 0.0049, 0.1610]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(87.5912, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(451.4088, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0046, 0.2190]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(134.3660, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(283.3660, grad_fn=<AddBackward0>), 'output':
tensor([[0.0038, 0.0051, 0.1069]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(61.7993, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(620.7993, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0043, 0.3320]], grad_fn=<SigmoidBackward0>), 'y': 558.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(214.8868, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1237.8868, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0036, 0.7434]], grad_fn=<SigmoidBackward0>), 'y': 1022.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(94.8459, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1061.8459, grad_fn=<AddBackward0>), 'output':
tensor([[0.0036, 0.0050, 0.6260]], grad_fn=<SigmoidBackward0>), 'y': 966.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(8.9751, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(401.9751, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0048, 0.1861]], grad_fn=<SigmoidBackward0>), 'y': 392.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(68.2781, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(664.7219, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0042, 0.3613]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(116.6541, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(422.3459, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0046, 0.1997]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.5060, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1002.5060, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0041, 0.5865]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(89.4203, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(530.5797, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0044, 0.2718]], grad_fn=<SigmoidBackward0>), 'y': 620.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.0224, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(590.9776, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0044, 0.3121]], grad_fn=<SigmoidBackward0>), 'y': 595.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(101.7434, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(631.2566, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0041, 0.3390]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(2.8638, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(793.8638, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0045, 0.4473]], grad_fn=<SigmoidBackward0>), 'y': 790.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(108.1356, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(963.1356, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0044, 0.5602]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.2644, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(458.7356, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0045, 0.2239]], grad_fn=<SigmoidBackward0>), 'y': 521.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(115.2941, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(941.7059, grad_fn=<AddBackward0>), 'output':
tensor([[0.0035, 0.0046, 0.5459]], grad_fn=<SigmoidBackward0>), 'y': 1057.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(173.3077, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(312.3077, grad_fn=<AddBackward0>), 'output':
tensor([[0.0038, 0.0049, 0.1262]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(54.3545, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(412.3545, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0048, 0.1930]], grad_fn=<SigmoidBackward0>), 'y': 357.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(100.8152, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(952.8152, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0048, 0.5533]], grad_fn=<SigmoidBackward0>), 'y': 851.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(97.9708, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(633.0292, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0041, 0.3402]], grad_fn=<SigmoidBackward0>), 'y': 731.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(120.0226, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1047.0226, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0040, 0.6162]], grad_fn=<SigmoidBackward0>), 'y': 926.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(201.2673, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(869.7327, grad_fn=<AddBackward0>), 'output':
tensor([[0.0035, 0.0047, 0.4979]], grad_fn=<SigmoidBackward0>), 'y': 1071.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.3644, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(975.6356, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0044, 0.5685]], grad_fn=<SigmoidBackward0>), 'y': 979.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(175.4818, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(928.5182, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0045, 0.5371]], grad_fn=<SigmoidBackward0>), 'y': 1104.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(34.2473, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1029.7527, grad_fn=<AddBackward0>), 'output':
tensor([[0.0035, 0.0048, 0.6046]], grad_fn=<SigmoidBackward0>), 'y': 1064.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(193.6667, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(788.6667, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0044, 0.4439]], grad_fn=<SigmoidBackward0>), 'y': 594.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(206.3531, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(891.3531, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0043, 0.5124]], grad_fn=<SigmoidBackward0>), 'y': 684.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(89.6977, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(582.6977, grad_fn=<AddBackward0>), 'output':
tensor([[0.0035, 0.0046, 0.3065]], grad_fn=<SigmoidBackward0>), 'y': 492.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(163.5002, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(395.5002, grad_fn=<AddBackward0>), 'output':
tensor([[0.0036, 0.0047, 0.1817]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(125.9152, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1151.9152, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0039, 0.6861]], grad_fn=<SigmoidBackward0>), 'y': 1025.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(65.6573, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(851.3427, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0044, 0.4857]], grad_fn=<SigmoidBackward0>), 'y': 917.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(43.4721, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(858.4721, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0042, 0.4905]], grad_fn=<SigmoidBackward0>), 'y': 814.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(44.1489, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(379.1489, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0047, 0.1709]], grad_fn=<SigmoidBackward0>), 'y': 334.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(43.3604, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(327.3604, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0050, 0.1363]], grad_fn=<SigmoidBackward0>), 'y': 283.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(226.3101, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(827.6899, grad_fn=<AddBackward0>), 'output':
tensor([[0.0039, 0.0052, 0.4698]], grad_fn=<SigmoidBackward0>), 'y': 1054.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(72.9581, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(222.9581, grad_fn=<AddBackward0>), 'output':
tensor([[0.0037, 0.0050, 0.0667]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(166.0556, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(505.9444, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0042, 0.2554]], grad_fn=<SigmoidBackward0>), 'y': 672.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(376.6260, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(738.3740, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0044, 0.4104]], grad_fn=<SigmoidBackward0>), 'y': 1115.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(42.9789, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(253.9789, grad_fn=<AddBackward0>), 'output':
tensor([[0.0037, 0.0050, 0.0874]], grad_fn=<SigmoidBackward0>), 'y': 210.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(117.3685, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(651.6315, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0047, 0.3525]], grad_fn=<SigmoidBackward0>), 'y': 769.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(49.0258, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(231.0258, grad_fn=<AddBackward0>), 'output':
tensor([[0.0042, 0.0053, 0.0720]], grad_fn=<SigmoidBackward0>), 'y': 181.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(85.3494, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(751.6506, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0039, 0.4193]], grad_fn=<SigmoidBackward0>), 'y': 837.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.5209, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(370.4791, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0043, 0.1651]], grad_fn=<SigmoidBackward0>), 'y': 371.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.3087, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(428.6913, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0044, 0.2039]], grad_fn=<SigmoidBackward0>), 'y': 433.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.0144, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1089.6694, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0045, 0.6445]], grad_fn=<SigmoidBackward0>), 'y': 1089.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(92.7966, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(578.7966, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0046, 0.3040]], grad_fn=<SigmoidBackward0>), 'y': 485.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(101.8417, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(567.8417, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0040, 0.2967]], grad_fn=<SigmoidBackward0>), 'y': 465.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(172.1333, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1192.1333, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.7129]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(32.3820, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(464.3820, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0044, 0.2277]], grad_fn=<SigmoidBackward0>), 'y': 431.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(123.2791, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(298.2791, grad_fn=<AddBackward0>), 'output':
tensor([[0.0042, 0.0055, 0.1168]], grad_fn=<SigmoidBackward0>), 'y': 174.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(67.0700, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(701.0700, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0043, 0.3855]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(108.6203, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(257.6203, grad_fn=<AddBackward0>), 'output':
tensor([[0.0037, 0.0050, 0.0898]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(71.1432, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(719.8568, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0043, 0.3980]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.1633, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(284.1633, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0043, 0.1076]], grad_fn=<SigmoidBackward0>), 'y': 280.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(20.8898, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(265.1102, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0049, 0.0948]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(145.5369, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(615.4631, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0044, 0.3284]], grad_fn=<SigmoidBackward0>), 'y': 761.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(59.1164, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(797.8836, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0045, 0.4500]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(91.3761, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(590.6239, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0045, 0.3119]], grad_fn=<SigmoidBackward0>), 'y': 682.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(68.2925, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(580.7075, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0038, 0.3053]], grad_fn=<SigmoidBackward0>), 'y': 649.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(34.4031, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(364.5969, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0043, 0.1612]], grad_fn=<SigmoidBackward0>), 'y': 399.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(50.1835, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(555.1835, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0045, 0.2882]], grad_fn=<SigmoidBackward0>), 'y': 504.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(78.8453, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(678.8453, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0045, 0.3707]], grad_fn=<SigmoidBackward0>), 'y': 599.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(154.5980, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1178.5980, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0035, 0.7039]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(24.9113, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(464.9113, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0045, 0.2281]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(155.2876, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1030.2876, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0049, 0.6049]], grad_fn=<SigmoidBackward0>), 'y': 874.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(50.0760, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(373.9240, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0042, 0.1674]], grad_fn=<SigmoidBackward0>), 'y': 424.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(60.3289, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(703.6711, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0046, 0.3872]], grad_fn=<SigmoidBackward0>), 'y': 764.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(59.1297, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(291.1297, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0046, 0.1122]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(103.1081, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(897.8919, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0044, 0.5167]], grad_fn=<SigmoidBackward0>), 'y': 1001.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(104.6133, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(299.6133, grad_fn=<AddBackward0>), 'output':
tensor([[0.0037, 0.0051, 0.1178]], grad_fn=<SigmoidBackward0>), 'y': 194.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(88.9082, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(614.0918, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0043, 0.3275]], grad_fn=<SigmoidBackward0>), 'y': 703.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.2198, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(269.2198, grad_fn=<AddBackward0>), 'output':
tensor([[0.0035, 0.0052, 0.0975]], grad_fn=<SigmoidBackward0>), 'y': 265.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(89.2530, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(902.7470, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0042, 0.5200]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(40.1568, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(698.1568, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0040, 0.3836]], grad_fn=<SigmoidBackward0>), 'y': 657.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(63.2673, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(350.2673, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0049, 0.1516]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.1954, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(404.8749, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0044, 0.1880]], grad_fn=<SigmoidBackward0>), 'y': 405.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.6538, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1116.6538, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0045, 0.6625]], grad_fn=<SigmoidBackward0>), 'y': 1086.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(116.9922, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(976.0078, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0046, 0.5688]], grad_fn=<SigmoidBackward0>), 'y': 1093.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(179.4990, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(318.4990, grad_fn=<AddBackward0>), 'output':
tensor([[0.0037, 0.0048, 0.1304]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(53.2335, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(796.2335, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0037, 0.4490]], grad_fn=<SigmoidBackward0>), 'y': 742.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(17.4133, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(393.4133, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0045, 0.1804]], grad_fn=<SigmoidBackward0>), 'y': 375.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(90.7432, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(409.2568, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0046, 0.1909]], grad_fn=<SigmoidBackward0>), 'y': 500.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.1282, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(863.8718, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0047, 0.4940]], grad_fn=<SigmoidBackward0>), 'y': 900.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(47.9434, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(396.9434, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0044, 0.1828]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(122.0863, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(782.9137, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0046, 0.4400]], grad_fn=<SigmoidBackward0>), 'y': 905.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(30.9147, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(912.0853, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0047, 0.5262]], grad_fn=<SigmoidBackward0>), 'y': 943.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(87.1741, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(385.8259, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0040, 0.1754]], grad_fn=<SigmoidBackward0>), 'y': 473.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(109.9511, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(389.9511, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0043, 0.1781]], grad_fn=<SigmoidBackward0>), 'y': 279.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(65.2517, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1038.2517, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0043, 0.6103]], grad_fn=<SigmoidBackward0>), 'y': 972.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(106.3838, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(498.3838, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0045, 0.2504]], grad_fn=<SigmoidBackward0>), 'y': 391.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(147.2480, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(320.2480, grad_fn=<AddBackward0>), 'output':
tensor([[0.0038, 0.0050, 0.1315]], grad_fn=<SigmoidBackward0>), 'y': 172.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(141.5470, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(390.5470, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0047, 0.1784]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(22.7273, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(416.2727, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0044, 0.1956]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(108.7391, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(357.7391, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0047, 0.1566]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(33.4475, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(272.4475, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0047, 0.0997]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(37.3167, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(282.3167, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0049, 0.1063]], grad_fn=<SigmoidBackward0>), 'y': 244.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(125.3246, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(631.6754, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0046, 0.3392]], grad_fn=<SigmoidBackward0>), 'y': 757.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(112.3314, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(788.6686, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0046, 0.4439]], grad_fn=<SigmoidBackward0>), 'y': 901.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(284.9343, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(729.0657, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0045, 0.4042]], grad_fn=<SigmoidBackward0>), 'y': 1014.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(158.1113, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(457.8887, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0045, 0.2234]], grad_fn=<SigmoidBackward0>), 'y': 616.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.5029, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(457.4971, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0042, 0.2231]], grad_fn=<SigmoidBackward0>), 'y': 520.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(108.0251, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(985.0251, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0047, 0.5748]], grad_fn=<SigmoidBackward0>), 'y': 876.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(95.7377, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(671.7377, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0047, 0.3659]], grad_fn=<SigmoidBackward0>), 'y': 575.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.3960, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1026.3960, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0045, 0.6024]], grad_fn=<SigmoidBackward0>), 'y': 967.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(8.8326, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(515.1674, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0045, 0.2616]], grad_fn=<SigmoidBackward0>), 'y': 524.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(187.6540, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(339.6540, grad_fn=<AddBackward0>), 'output':
tensor([[0.0036, 0.0049, 0.1445]], grad_fn=<SigmoidBackward0>), 'y': 151.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(89.4529, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1050.4529, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0048, 0.6184]], grad_fn=<SigmoidBackward0>), 'y': 960.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(59.9213, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1005.0787, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0046, 0.5882]], grad_fn=<SigmoidBackward0>), 'y': 1065.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(156.1141, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(300.1141, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0047, 0.1182]], grad_fn=<SigmoidBackward0>), 'y': 143.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.0178, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(676.9822, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0041, 0.3695]], grad_fn=<SigmoidBackward0>), 'y': 695.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.5373, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(848.4627, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0044, 0.4838]], grad_fn=<SigmoidBackward0>), 'y': 911.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(5.4587, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(913.5413, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0041, 0.5272]], grad_fn=<SigmoidBackward0>), 'y': 919.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(1.7395, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1063.7395, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0044, 0.6273]], grad_fn=<SigmoidBackward0>), 'y': 1061.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(87.8543, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(374.8543, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0048, 0.1680]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(194.7581, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1135.7581, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.6753]], grad_fn=<SigmoidBackward0>), 'y': 940.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(402.4158, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(530.4158, grad_fn=<AddBackward0>), 'output':
tensor([[0.0035, 0.0046, 0.2717]], grad_fn=<SigmoidBackward0>), 'y':
127.50000000000001}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(55.3081, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(972.3081, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0042, 0.5663]], grad_fn=<SigmoidBackward0>), 'y': 916.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(16.5749, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(329.5749, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0048, 0.1378]], grad_fn=<SigmoidBackward0>), 'y': 312.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(74.2317, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(433.7683, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0043, 0.2073]], grad_fn=<SigmoidBackward0>), 'y': 508.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(106.8090, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(403.1910, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0043, 0.1869]], grad_fn=<SigmoidBackward0>), 'y': 510.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(16.9688, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(406.9688, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0046, 0.1894]], grad_fn=<SigmoidBackward0>), 'y': 389.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(134.5531, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(287.5531, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0048, 0.1098]], grad_fn=<SigmoidBackward0>), 'y': 152.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(24.2926, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(323.7074, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0043, 0.1339]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(112.1812, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(349.8188, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0040, 0.1514]], grad_fn=<SigmoidBackward0>), 'y': 462.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(111.1393, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(500.8607, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0043, 0.2520]], grad_fn=<SigmoidBackward0>), 'y': 612.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(144.0820, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(596.9180, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.3161]], grad_fn=<SigmoidBackward0>), 'y': 741.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(162.3727, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(701.6273, grad_fn=<AddBackward0>), 'output':
tensor([[0.0035, 0.0050, 0.3858]], grad_fn=<SigmoidBackward0>), 'y': 864.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(28.1774, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(926.1774, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0045, 0.5356]], grad_fn=<SigmoidBackward0>), 'y': 897.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(136.0284, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(453.9716, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0044, 0.2208]], grad_fn=<SigmoidBackward0>), 'y': 590.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(45.5306, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(983.4694, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0039, 0.5738]], grad_fn=<SigmoidBackward0>), 'y': 1029.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(219.6293, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(901.3707, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0046, 0.5190]], grad_fn=<SigmoidBackward0>), 'y': 1121.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.8336, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(542.1664, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0040, 0.2796]], grad_fn=<SigmoidBackward0>), 'y': 561.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(129.0571, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(955.0571, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0044, 0.5548]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(284.1984, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(498.1984, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0048, 0.2502]], grad_fn=<SigmoidBackward0>), 'y': 213.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(88.3012, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(652.3012, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0040, 0.3530]], grad_fn=<SigmoidBackward0>), 'y': 563.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(252.8905, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1159.8905, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0042, 0.6914]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(195.1902, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1284.1902, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0044, 0.7742]], grad_fn=<SigmoidBackward0>), 'y': 1088.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(154.4563, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1147.4563, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0040, 0.6831]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(142.0300, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(381.0300, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0046, 0.1721]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(10.1082, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1085.1082, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0046, 0.6415]], grad_fn=<SigmoidBackward0>), 'y': 1074.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.7563, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(512.7563, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0042, 0.2600]], grad_fn=<SigmoidBackward0>), 'y': 507.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(90.1348, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(240.1348, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0048, 0.0782]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(2.9493, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(734.0507, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0037, 0.4075]], grad_fn=<SigmoidBackward0>), 'y': 737.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(1.0213, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(221.9787, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0043, 0.0661]], grad_fn=<SigmoidBackward0>), 'y': 223.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(181.5850, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(755.4150, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0039, 0.4218]], grad_fn=<SigmoidBackward0>), 'y': 937.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(203.3619, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(625.6381, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.3352]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(70.2263, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(274.7737, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0046, 0.1013]], grad_fn=<SigmoidBackward0>), 'y': 345.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(80.2170, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(776.7830, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0043, 0.4360]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(146.2869, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(467.7131, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0042, 0.2299]], grad_fn=<SigmoidBackward0>), 'y': 614.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.5153, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(307.5153, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0046, 0.1231]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(112.7205, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(385.2795, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0046, 0.1750]], grad_fn=<SigmoidBackward0>), 'y': 498.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.2567, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(312.2166, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0049, 0.1262]], grad_fn=<SigmoidBackward0>), 'y': 311.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(99.3893, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(328.3893, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0043, 0.1370]], grad_fn=<SigmoidBackward0>), 'y': 228.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(81.2024, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(360.7976, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0042, 0.1587]], grad_fn=<SigmoidBackward0>), 'y': 442.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(127.7428, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(406.7428, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0042, 0.1893]], grad_fn=<SigmoidBackward0>), 'y': 278.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(86.2197, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(493.2197, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0042, 0.2470]], grad_fn=<SigmoidBackward0>), 'y': 406.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(122.0223, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1142.0223, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.6795]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(57.9343, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(436.0657, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0047, 0.2088]], grad_fn=<SigmoidBackward0>), 'y': 494.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(73.6119, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1055.6119, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.6219]], grad_fn=<SigmoidBackward0>), 'y': 981.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(35.8143, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(743.8143, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0039, 0.4140]], grad_fn=<SigmoidBackward0>), 'y': 707.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(54.4619, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(272.4619, grad_fn=<AddBackward0>), 'output':
tensor([[0.0036, 0.0050, 0.0997]], grad_fn=<SigmoidBackward0>), 'y': 217.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(137.4469, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(768.5531, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0042, 0.4305]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(44.8292, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(827.1708, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0044, 0.4696]], grad_fn=<SigmoidBackward0>), 'y': 872.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(225.3422, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(833.6578, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0043, 0.4739]], grad_fn=<SigmoidBackward0>), 'y': 1059.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(1.8942, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(326.1058, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0044, 0.1355]], grad_fn=<SigmoidBackward0>), 'y': 328.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.2714, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(702.2714, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.3863]], grad_fn=<SigmoidBackward0>), 'y': 670.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(2.5880, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(580.5880, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0047, 0.3052]], grad_fn=<SigmoidBackward0>), 'y': 577.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(34.0702, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(337.0702, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0047, 0.1428]], grad_fn=<SigmoidBackward0>), 'y': 302.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.1896, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(512.8104, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0039, 0.2600]], grad_fn=<SigmoidBackward0>), 'y': 549.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(12.7585, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(271.7585, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0046, 0.0993]], grad_fn=<SigmoidBackward0>), 'y': 258.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(87.6906, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(256.6906, grad_fn=<AddBackward0>), 'output':
tensor([[0.0036, 0.0048, 0.0892]], grad_fn=<SigmoidBackward0>), 'y': 168.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(136.3257, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(537.6743, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0041, 0.2766]], grad_fn=<SigmoidBackward0>), 'y': 674.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(169.6398, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(846.3602, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.4824]], grad_fn=<SigmoidBackward0>), 'y': 1016.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(161.3190, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(663.6810, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0044, 0.3606]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(1.8784, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(642.1216, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.3463]], grad_fn=<SigmoidBackward0>), 'y': 644.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(214.3124, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1236.3124, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0034, 0.7424]], grad_fn=<SigmoidBackward0>), 'y': 1021.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(83.6134, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(564.6134, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0039, 0.2946]], grad_fn=<SigmoidBackward0>), 'y': 480.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(117.3530, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1088.3530, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0044, 0.6437]], grad_fn=<SigmoidBackward0>), 'y': 970.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(156.1396, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1180.1396, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0033, 0.7050]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(96.8870, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(471.1130, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0044, 0.2322]], grad_fn=<SigmoidBackward0>), 'y': 568.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(26.9813, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(838.9813, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0039, 0.4775]], grad_fn=<SigmoidBackward0>), 'y': 811.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(10.3938, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(519.6062, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0043, 0.2645]], grad_fn=<SigmoidBackward0>), 'y': 530.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(61.2847, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(985.2847, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.5750]], grad_fn=<SigmoidBackward0>), 'y': 923.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(93.6672, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(545.3328, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.2817]], grad_fn=<SigmoidBackward0>), 'y': 639.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.0664, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(330.0664, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0044, 0.1382]], grad_fn=<SigmoidBackward0>), 'y': 290.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(49.0581, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(583.9419, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0041, 0.3075]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(124.7170, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(363.2830, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0045, 0.1603]], grad_fn=<SigmoidBackward0>), 'y': 488.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(43.4346, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(747.5654, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0040, 0.4165]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(85.1874, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(940.1874, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0041, 0.5449]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(108.2601, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(883.7399, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0040, 0.5073]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(118.7665, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1058.7665, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0038, 0.6240]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(51.9067, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(659.9067, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0043, 0.3581]], grad_fn=<SigmoidBackward0>), 'y': 607.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(137.1064, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(997.1064, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.5829]], grad_fn=<SigmoidBackward0>), 'y': 859.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(70.1754, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1004.1754, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0036, 0.5876]], grad_fn=<SigmoidBackward0>), 'y': 933.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(54.9632, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(774.0368, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0040, 0.4342]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(60.2764, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(762.7236, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0043, 0.4266]], grad_fn=<SigmoidBackward0>), 'y': 823.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(151.8235, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(466.1765, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.2289]], grad_fn=<SigmoidBackward0>), 'y': 618.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(115.0536, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(424.9464, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0042, 0.2014]], grad_fn=<SigmoidBackward0>), 'y': 540.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(11.1008, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(826.8992, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.4695]], grad_fn=<SigmoidBackward0>), 'y': 838.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(95.8096, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(344.8096, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0045, 0.1480]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(74.1678, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(464.8322, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0043, 0.2280]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(126.6281, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(275.6281, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0047, 0.1018]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(81.9650, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(640.9650, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0040, 0.3455]], grad_fn=<SigmoidBackward0>), 'y': 558.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(212.3547, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1235.3547, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0033, 0.7418]], grad_fn=<SigmoidBackward0>), 'y': 1022.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(94.5708, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1061.5708, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0046, 0.6258]], grad_fn=<SigmoidBackward0>), 'y': 966.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.6396, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(411.6396, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0044, 0.1926]], grad_fn=<SigmoidBackward0>), 'y': 392.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(14.5731, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(718.4269, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0038, 0.3971]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(83.7514, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(455.2486, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0043, 0.2216]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(80.5815, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1020.5815, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0038, 0.5986]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(38.2861, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(581.7139, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.3060]], grad_fn=<SigmoidBackward0>), 'y': 620.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(47.0458, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(643.0458, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0041, 0.3469]], grad_fn=<SigmoidBackward0>), 'y': 595.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(73.1774, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(659.8226, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0038, 0.3581]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(20.9885, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(769.0115, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0041, 0.4308]], grad_fn=<SigmoidBackward0>), 'y': 790.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(76.0611, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(931.0611, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0041, 0.5389]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(55.0822, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(465.9178, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0042, 0.2288]], grad_fn=<SigmoidBackward0>), 'y': 521.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(105.9232, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(951.0768, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0043, 0.5522]], grad_fn=<SigmoidBackward0>), 'y': 1057.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(174.0948, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(313.0948, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0046, 0.1268]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(71.5991, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(429.5991, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0044, 0.2045]], grad_fn=<SigmoidBackward0>), 'y': 357.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(143.8545, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(995.8545, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0045, 0.5820]], grad_fn=<SigmoidBackward0>), 'y': 851.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(11.9042, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(719.0958, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0038, 0.3976]], grad_fn=<SigmoidBackward0>), 'y': 731.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(176.2676, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1103.2676, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0037, 0.6537]], grad_fn=<SigmoidBackward0>), 'y': 926.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(122.4788, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(948.5212, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0044, 0.5505]], grad_fn=<SigmoidBackward0>), 'y': 1071.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(78.1777, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1058.1777, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0041, 0.6236]], grad_fn=<SigmoidBackward0>), 'y': 979.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(134.8339, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(969.1661, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0042, 0.5643]], grad_fn=<SigmoidBackward0>), 'y': 1104.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(24.7693, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1039.2307, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0045, 0.6109]], grad_fn=<SigmoidBackward0>), 'y': 1064.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(170.0060, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(765.0060, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0041, 0.4282]], grad_fn=<SigmoidBackward0>), 'y': 594.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(156.8270, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(841.8270, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.4794]], grad_fn=<SigmoidBackward0>), 'y': 684.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.0503, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(512.0503, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0043, 0.2595]], grad_fn=<SigmoidBackward0>), 'y': 492.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(92.5673, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(324.5673, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0043, 0.1345]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(9.9169, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1015.0831, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.5949]], grad_fn=<SigmoidBackward0>), 'y': 1025.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(157.8662, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(759.1338, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0040, 0.4242]], grad_fn=<SigmoidBackward0>), 'y': 917.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.0679, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(809.9321, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.4581]], grad_fn=<SigmoidBackward0>), 'y': 814.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(44.7455, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(379.7455, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0043, 0.1713]], grad_fn=<SigmoidBackward0>), 'y': 334.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(79.7711, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(363.7711, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0046, 0.1606]], grad_fn=<SigmoidBackward0>), 'y': 283.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(87.8485, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(966.1515, grad_fn=<AddBackward0>), 'output':
tensor([[0.0035, 0.0048, 0.5622]], grad_fn=<SigmoidBackward0>), 'y': 1054.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(127.8809, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(277.8809, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0047, 0.1033]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(72.9960, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(745.9960, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0039, 0.4155]], grad_fn=<SigmoidBackward0>), 'y': 672.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(125.8503, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(989.1497, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0041, 0.5776]], grad_fn=<SigmoidBackward0>), 'y': 1115.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(132.4373, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(343.4373, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0047, 0.1471]], grad_fn=<SigmoidBackward0>), 'y': 210.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(123.3492, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(893.3492, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0044, 0.5137]], grad_fn=<SigmoidBackward0>), 'y': 769.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(101.3391, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(283.3391, grad_fn=<AddBackward0>), 'output':
tensor([[0.0037, 0.0050, 0.1069]], grad_fn=<SigmoidBackward0>), 'y': 181.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(73.5657, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(911.5657, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.5259]], grad_fn=<SigmoidBackward0>), 'y': 837.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(11.0651, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(383.0651, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.1735]], grad_fn=<SigmoidBackward0>), 'y': 371.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.7596, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(376.2404, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0041, 0.1690]], grad_fn=<SigmoidBackward0>), 'y': 433.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(197.7446, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(891.2554, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0042, 0.5123]], grad_fn=<SigmoidBackward0>), 'y': 1089.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(102.6426, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(382.3574, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0042, 0.1730]], grad_fn=<SigmoidBackward0>), 'y': 485.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(110.4446, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(354.5554, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0037, 0.1546]], grad_fn=<SigmoidBackward0>), 'y': 465.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(106.7919, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(912.2081, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.5263]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(98.5322, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(332.4678, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.1398]], grad_fn=<SigmoidBackward0>), 'y': 431.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(69.1530, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(244.1530, grad_fn=<AddBackward0>), 'output':
tensor([[0.0037, 0.0051, 0.0808]], grad_fn=<SigmoidBackward0>), 'y': 174.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.6900, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(665.6900, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.3620]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(106.5859, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(255.5859, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0046, 0.0885]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(22.4352, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(814.4352, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0040, 0.4611]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(32.9737, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(313.9737, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.1275]], grad_fn=<SigmoidBackward0>), 'y': 280.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.3184, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(291.3184, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0045, 0.1123]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(66.5527, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(694.4473, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.3811]], grad_fn=<SigmoidBackward0>), 'y': 761.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(5.3910, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(863.3910, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0042, 0.4937]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(77.8970, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(604.1030, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.3209]], grad_fn=<SigmoidBackward0>), 'y': 682.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(101.2834, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(547.7166, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.2833]], grad_fn=<SigmoidBackward0>), 'y': 649.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(89.1270, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(309.8730, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.1248]], grad_fn=<SigmoidBackward0>), 'y': 399.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(61.6662, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(442.3338, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0042, 0.2130]], grad_fn=<SigmoidBackward0>), 'y': 504.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.5507, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(542.4493, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.2798]], grad_fn=<SigmoidBackward0>), 'y': 599.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(43.7043, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1067.7043, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0032, 0.6300]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.4892, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(420.5108, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.1985]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(147.0268, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1022.0268, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0045, 0.5995]], grad_fn=<SigmoidBackward0>), 'y': 874.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(20.1577, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(403.8423, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0039, 0.1874]], grad_fn=<SigmoidBackward0>), 'y': 424.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(42.7653, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(807.7653, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0043, 0.4566]], grad_fn=<SigmoidBackward0>), 'y': 764.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(97.1248, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(329.1248, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0042, 0.1375]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(2.2502, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(998.7498, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.5840]], grad_fn=<SigmoidBackward0>), 'y': 1001.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(143.0301, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(338.0301, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0047, 0.1434]], grad_fn=<SigmoidBackward0>), 'y': 194.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(16.3392, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(720.3392, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0040, 0.3984]], grad_fn=<SigmoidBackward0>), 'y': 703.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(9.1354, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(275.1354, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0048, 0.1015]], grad_fn=<SigmoidBackward0>), 'y': 265.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(106.0547, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(885.9453, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0038, 0.5088]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.0265, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(657.7302, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0037, 0.3567]], grad_fn=<SigmoidBackward0>), 'y': 657.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.1549, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(306.1549, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0045, 0.1222]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(49.0778, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(355.9222, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0041, 0.1554]], grad_fn=<SigmoidBackward0>), 'y': 405.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.5925, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1027.4075, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0041, 0.6031]], grad_fn=<SigmoidBackward0>), 'y': 1086.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(171.0493, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(921.9507, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0043, 0.5328]], grad_fn=<SigmoidBackward0>), 'y': 1093.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(162.8870, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(301.8870, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0044, 0.1194]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(90.7611, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(833.7611, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0034, 0.4740]], grad_fn=<SigmoidBackward0>), 'y': 742.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(35.3174, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(411.3174, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0041, 0.1924]], grad_fn=<SigmoidBackward0>), 'y': 375.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(32.0576, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(467.9424, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0043, 0.2301]], grad_fn=<SigmoidBackward0>), 'y': 500.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.1997, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(963.1997, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0044, 0.5603]], grad_fn=<SigmoidBackward0>), 'y': 900.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(85.5378, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(434.5378, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0041, 0.2079]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(70.0123, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(834.9877, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0043, 0.4748]], grad_fn=<SigmoidBackward0>), 'y': 905.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(38.4117, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(904.5883, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0044, 0.5212]], grad_fn=<SigmoidBackward0>), 'y': 943.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(82.2889, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(390.7111, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0037, 0.1787]], grad_fn=<SigmoidBackward0>), 'y': 473.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(84.2667, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(364.2667, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0040, 0.1610]], grad_fn=<SigmoidBackward0>), 'y': 279.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.7988, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(977.7988, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.5700]], grad_fn=<SigmoidBackward0>), 'y': 972.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(59.3242, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(451.3242, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0041, 0.2190]], grad_fn=<SigmoidBackward0>), 'y': 391.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(112.6369, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(285.6369, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0046, 0.1085]], grad_fn=<SigmoidBackward0>), 'y': 172.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(85.5479, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(334.5479, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0044, 0.1412]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.2228, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(380.7772, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0041, 0.1720]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(53.4598, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(302.4598, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0044, 0.1198]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(2.3619, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(235.6381, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0044, 0.0752]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(1.7950, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(246.7950, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0045, 0.0826]], grad_fn=<SigmoidBackward0>), 'y': 244.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(178.5501, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(578.4499, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0043, 0.3038]], grad_fn=<SigmoidBackward0>), 'y': 757.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(161.3820, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(739.6180, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0043, 0.4112]], grad_fn=<SigmoidBackward0>), 'y': 901.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(319.9355, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(694.0645, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0041, 0.3809]], grad_fn=<SigmoidBackward0>), 'y': 1014.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(156.9428, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(459.0572, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0042, 0.2242]], grad_fn=<SigmoidBackward0>), 'y': 616.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(68.2570, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(451.7430, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.2193]], grad_fn=<SigmoidBackward0>), 'y': 520.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(84.9648, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(961.9648, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0044, 0.5594]], grad_fn=<SigmoidBackward0>), 'y': 876.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(88.8838, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(664.8838, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0043, 0.3614]], grad_fn=<SigmoidBackward0>), 'y': 575.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.2102, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(997.2102, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0042, 0.5830]], grad_fn=<SigmoidBackward0>), 'y': 967.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.6266, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(529.6266, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0042, 0.2712]], grad_fn=<SigmoidBackward0>), 'y': 524.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(158.1166, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(310.1166, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0046, 0.1248]], grad_fn=<SigmoidBackward0>), 'y': 151.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(5.9030, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(954.0970, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0045, 0.5542]], grad_fn=<SigmoidBackward0>), 'y': 960.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(107.6494, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(957.3506, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0043, 0.5564]], grad_fn=<SigmoidBackward0>), 'y': 1065.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(135.6985, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(279.6985, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0044, 0.1046]], grad_fn=<SigmoidBackward0>), 'y': 143.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(17.4207, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(677.5793, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0038, 0.3699]], grad_fn=<SigmoidBackward0>), 'y': 695.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(50.7249, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(860.2751, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0041, 0.4917]], grad_fn=<SigmoidBackward0>), 'y': 911.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(25.9266, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(945.9266, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0038, 0.5488]], grad_fn=<SigmoidBackward0>), 'y': 919.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(3.0229, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1057.9771, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0041, 0.6235]], grad_fn=<SigmoidBackward0>), 'y': 1061.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(72.3142, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(359.3142, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0044, 0.1577]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(183.8724, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1124.8724, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0038, 0.6681]], grad_fn=<SigmoidBackward0>), 'y': 940.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(390.5531, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(518.5531, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0043, 0.2638]], grad_fn=<SigmoidBackward0>), 'y':
127.50000000000001}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(79.8461, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(996.8461, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0039, 0.5827]], grad_fn=<SigmoidBackward0>), 'y': 916.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(28.2798, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(341.2798, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0045, 0.1456]], grad_fn=<SigmoidBackward0>), 'y': 312.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(27.2586, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(480.7414, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0041, 0.2387]], grad_fn=<SigmoidBackward0>), 'y': 508.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.5928, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(453.4072, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.2204]], grad_fn=<SigmoidBackward0>), 'y': 510.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(55.0957, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(445.0957, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0043, 0.2149]], grad_fn=<SigmoidBackward0>), 'y': 389.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(155.3527, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(308.3527, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0045, 0.1237]], grad_fn=<SigmoidBackward0>), 'y': 152.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(9.5011, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(358.5011, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0040, 0.1572]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(73.2761, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(388.7239, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.1773]], grad_fn=<SigmoidBackward0>), 'y': 462.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(70.1039, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(541.8961, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.2794]], grad_fn=<SigmoidBackward0>), 'y': 612.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(102.0991, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(638.9009, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0034, 0.3441]], grad_fn=<SigmoidBackward0>), 'y': 741.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(158.7681, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(705.2319, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0047, 0.3883]], grad_fn=<SigmoidBackward0>), 'y': 864.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.3488, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(929.3488, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0042, 0.5377]], grad_fn=<SigmoidBackward0>), 'y': 897.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(124.2255, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(465.7745, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0041, 0.2287]], grad_fn=<SigmoidBackward0>), 'y': 590.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.1222, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(970.8778, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.5654]], grad_fn=<SigmoidBackward0>), 'y': 1029.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(230.7224, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(890.2776, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0043, 0.5117]], grad_fn=<SigmoidBackward0>), 'y': 1121.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(30.4509, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(530.5491, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.2719]], grad_fn=<SigmoidBackward0>), 'y': 561.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(117.3317, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(943.3317, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0041, 0.5471]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(242.7252, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(456.7252, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0044, 0.2226]], grad_fn=<SigmoidBackward0>), 'y': 213.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(60.4337, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(624.4337, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0037, 0.3345]], grad_fn=<SigmoidBackward0>), 'y': 563.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(227.0521, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1134.0521, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0039, 0.6742]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(164.4570, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1253.4570, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0041, 0.7538]], grad_fn=<SigmoidBackward0>), 'y': 1088.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(107.6855, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1100.6855, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0038, 0.6520]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(102.1891, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(341.1891, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0043, 0.1456]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(38.4453, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1035.5547, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0043, 0.6085]], grad_fn=<SigmoidBackward0>), 'y': 1074.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(10.6187, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(518.6187, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.2639]], grad_fn=<SigmoidBackward0>), 'y': 507.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(95.3699, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(245.3699, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0044, 0.0817]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(85.7296, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(823.7296, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.4674]], grad_fn=<SigmoidBackward0>), 'y': 737.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(6.5027, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(230.5027, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0040, 0.0718]], grad_fn=<SigmoidBackward0>), 'y': 223.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(169.4448, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(767.5552, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.4299]], grad_fn=<SigmoidBackward0>), 'y': 937.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(198.5005, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(630.4995, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.3385]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(86.1825, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(258.8175, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0043, 0.0907]], grad_fn=<SigmoidBackward0>), 'y': 345.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(146.3849, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(710.6151, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0040, 0.3919]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(184.5975, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(429.4025, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0039, 0.2044]], grad_fn=<SigmoidBackward0>), 'y': 614.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(11.0520, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(260.0520, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0043, 0.0915]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(164.4431, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(333.5569, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0043, 0.1405]], grad_fn=<SigmoidBackward0>), 'y': 498.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(53.8633, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(257.1367, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0045, 0.0895]], grad_fn=<SigmoidBackward0>), 'y': 311.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(38.7318, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(267.7318, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0040, 0.0966]], grad_fn=<SigmoidBackward0>), 'y': 228.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(138.6512, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(303.3488, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.1204]], grad_fn=<SigmoidBackward0>), 'y': 442.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(49.0909, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(328.0909, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0039, 0.1369]], grad_fn=<SigmoidBackward0>), 'y': 278.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(1.5149, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(404.4851, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0039, 0.1878]], grad_fn=<SigmoidBackward0>), 'y': 406.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(46.2753, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1066.2753, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.6291]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(76.8302, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(417.1698, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0044, 0.1962]], grad_fn=<SigmoidBackward0>), 'y': 494.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(50.7538, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1032.7538, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.6067]], grad_fn=<SigmoidBackward0>), 'y': 981.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(61.3555, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(769.3555, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.4311]], grad_fn=<SigmoidBackward0>), 'y': 707.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.8699, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(276.8699, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0046, 0.1027]], grad_fn=<SigmoidBackward0>), 'y': 217.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(67.0859, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(838.9141, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0039, 0.4774]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(38.5949, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(911.5949, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0042, 0.5259]], grad_fn=<SigmoidBackward0>), 'y': 872.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(159.8240, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(899.1760, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.5176]], grad_fn=<SigmoidBackward0>), 'y': 1059.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(1.0598, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(326.9402, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0041, 0.1361]], grad_fn=<SigmoidBackward0>), 'y': 328.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(12.4367, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(683.4367, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.3738]], grad_fn=<SigmoidBackward0>), 'y': 670.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.3281, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(547.6719, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0044, 0.2833]], grad_fn=<SigmoidBackward0>), 'y': 577.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(16.1336, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(319.1336, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0044, 0.1309]], grad_fn=<SigmoidBackward0>), 'y': 302.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(20.4836, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(528.5164, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0037, 0.2705]], grad_fn=<SigmoidBackward0>), 'y': 549.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(11.1551, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(270.1551, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0043, 0.0982]], grad_fn=<SigmoidBackward0>), 'y': 258.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(95.4615, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(264.4615, grad_fn=<AddBackward0>), 'output':
tensor([[0.0033, 0.0045, 0.0944]], grad_fn=<SigmoidBackward0>), 'y': 168.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(85.7744, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(588.2256, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.3103]], grad_fn=<SigmoidBackward0>), 'y': 674.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(102.2632, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(913.7368, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.5273]], grad_fn=<SigmoidBackward0>), 'y': 1016.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(73.3071, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(751.6929, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0041, 0.4193]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(104.3660, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(749.3660, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.4178]], grad_fn=<SigmoidBackward0>), 'y': 644.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(251.3820, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1273.3820, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.7672]], grad_fn=<SigmoidBackward0>), 'y': 1021.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(101.3336, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(582.3336, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.3064]], grad_fn=<SigmoidBackward0>), 'y': 480.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(96.5483, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1067.5483, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.6299]], grad_fn=<SigmoidBackward0>), 'y': 970.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(121.4761, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1145.4761, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0031, 0.6819]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(128.5365, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(439.4635, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0041, 0.2111]], grad_fn=<SigmoidBackward0>), 'y': 568.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.6801, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(754.3199, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.4211]], grad_fn=<SigmoidBackward0>), 'y': 811.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(34.3954, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(495.6046, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.2486]], grad_fn=<SigmoidBackward0>), 'y': 530.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(25.1575, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(949.1575, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.5510]], grad_fn=<SigmoidBackward0>), 'y': 923.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(76.3959, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(562.6041, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.2933]], grad_fn=<SigmoidBackward0>), 'y': 639.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.5206, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(322.5206, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0041, 0.1332]], grad_fn=<SigmoidBackward0>), 'y': 290.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(1.7805, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(631.2195, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.3390]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(80.5905, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(407.4095, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0042, 0.1898]], grad_fn=<SigmoidBackward0>), 'y': 488.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.0687, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(821.0687, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0038, 0.4656]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(91.7544, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(946.7544, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0038, 0.5493]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(105.3188, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(886.6812, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0037, 0.5093]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(75.8964, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1015.8964, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0036, 0.5955]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(14.7281, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(622.7281, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0041, 0.3333]], grad_fn=<SigmoidBackward0>), 'y': 607.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(59.2095, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(919.2095, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.5310]], grad_fn=<SigmoidBackward0>), 'y': 859.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(34.4447, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(898.5553, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0034, 0.5172]], grad_fn=<SigmoidBackward0>), 'y': 933.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(105.9397, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(723.0603, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.4002]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(79.5128, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(743.4872, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0040, 0.4138]], grad_fn=<SigmoidBackward0>), 'y': 823.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(133.9709, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(484.0291, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.2409]], grad_fn=<SigmoidBackward0>), 'y': 618.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(80.5381, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(459.4619, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.2245]], grad_fn=<SigmoidBackward0>), 'y': 540.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.4459, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(878.4459, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.5038]], grad_fn=<SigmoidBackward0>), 'y': 838.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(93.0630, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(342.0630, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0043, 0.1462]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(66.2588, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(472.7412, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0040, 0.2333]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(110.1727, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(259.1727, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0044, 0.0909]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.1409, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(590.1409, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.3116]], grad_fn=<SigmoidBackward0>), 'y': 558.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(145.7316, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1168.7316, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0031, 0.6974]], grad_fn=<SigmoidBackward0>), 'y': 1022.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.1930, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(952.8070, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0043, 0.5533]], grad_fn=<SigmoidBackward0>), 'y': 966.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.0989, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(373.9011, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0041, 0.1674]], grad_fn=<SigmoidBackward0>), 'y': 392.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.2328, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(732.8176, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.4067]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.4919, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(502.5081, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0040, 0.2532]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(145.8467, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1085.8467, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0036, 0.6421]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(98.9861, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(719.9861, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.3982]], grad_fn=<SigmoidBackward0>), 'y': 620.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(174.3057, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(770.3057, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.4317]], grad_fn=<SigmoidBackward0>), 'y': 595.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(44.4407, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(778.4407, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.4372]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.8249, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(809.8249, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0039, 0.4581]], grad_fn=<SigmoidBackward0>), 'y': 790.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(22.2842, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(831.7158, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0038, 0.4727]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(121.6225, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(399.3775, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.1844]], grad_fn=<SigmoidBackward0>), 'y': 521.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(248.0089, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(808.9911, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0040, 0.4575]], grad_fn=<SigmoidBackward0>), 'y': 1057.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(101.5904, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(240.5904, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0043, 0.0785]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(54.4510, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(302.5490, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0041, 0.1199]], grad_fn=<SigmoidBackward0>), 'y': 357.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(96.3849, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(754.6151, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0042, 0.4212]], grad_fn=<SigmoidBackward0>), 'y': 851.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(160.4453, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(570.5547, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0035, 0.2986]], grad_fn=<SigmoidBackward0>), 'y': 731.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.1586, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(963.1586, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.5603]], grad_fn=<SigmoidBackward0>), 'y': 926.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(208.3668, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(862.6332, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.4932]], grad_fn=<SigmoidBackward0>), 'y': 1071.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(15.1608, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(995.1608, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0038, 0.5816]], grad_fn=<SigmoidBackward0>), 'y': 979.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(155.5734, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(948.4266, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0039, 0.5504]], grad_fn=<SigmoidBackward0>), 'y': 1104.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(12.8203, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1051.1797, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0042, 0.6189]], grad_fn=<SigmoidBackward0>), 'y': 1064.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(197.1666, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(792.1666, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.4463]], grad_fn=<SigmoidBackward0>), 'y': 594.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(205.5649, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(890.5649, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.5119]], grad_fn=<SigmoidBackward0>), 'y': 684.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(70.1914, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(563.1914, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.2936]], grad_fn=<SigmoidBackward0>), 'y': 492.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(118.4901, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(350.4901, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0041, 0.1518]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(73.1134, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1099.1134, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.6510]], grad_fn=<SigmoidBackward0>), 'y': 1025.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(109.9906, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(807.0094, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0038, 0.4562]], grad_fn=<SigmoidBackward0>), 'y': 917.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(17.8539, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(832.8539, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.4734]], grad_fn=<SigmoidBackward0>), 'y': 814.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.0469, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(334.1937, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0041, 0.1410]], grad_fn=<SigmoidBackward0>), 'y': 334.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(8.9925, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(292.9925, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0044, 0.1135]], grad_fn=<SigmoidBackward0>), 'y': 283.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(251.4432, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(802.5568, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0046, 0.4531]], grad_fn=<SigmoidBackward0>), 'y': 1054.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(60.4536, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(210.4536, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0044, 0.0584]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(158.8186, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(513.1814, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.2603]], grad_fn=<SigmoidBackward0>), 'y': 672.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(360.0776, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(754.9224, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0039, 0.4214]], grad_fn=<SigmoidBackward0>), 'y': 1115.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.3715, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(247.3715, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0044, 0.0830]], grad_fn=<SigmoidBackward0>), 'y': 210.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(94.1632, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(674.8368, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0041, 0.3681]], grad_fn=<SigmoidBackward0>), 'y': 769.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(50.8804, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(232.8804, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0047, 0.0733]], grad_fn=<SigmoidBackward0>), 'y': 181.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(28.9861, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(808.0139, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.4569]], grad_fn=<SigmoidBackward0>), 'y': 837.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.6634, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(385.6634, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.1753]], grad_fn=<SigmoidBackward0>), 'y': 371.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(24.3507, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(458.3507, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0039, 0.2237]], grad_fn=<SigmoidBackward0>), 'y': 433.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(12.7886, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1076.2114, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.6356]], grad_fn=<SigmoidBackward0>), 'y': 1089.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(61.4357, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(547.4357, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0041, 0.2831]], grad_fn=<SigmoidBackward0>), 'y': 485.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(35.8148, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(501.8148, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0035, 0.2527]], grad_fn=<SigmoidBackward0>), 'y': 465.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(88.8983, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1108.8983, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.6575]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(27.6876, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(403.3124, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.1871]], grad_fn=<SigmoidBackward0>), 'y': 431.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(84.8098, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(259.8098, grad_fn=<AddBackward0>), 'output':
tensor([[0.0034, 0.0049, 0.0913]], grad_fn=<SigmoidBackward0>), 'y': 174.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.4720, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(673.4720, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.3672]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(86.8348, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(235.8348, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0044, 0.0753]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(91.2135, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(699.7865, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.3847]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(12.4847, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(267.5153, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.0965]], grad_fn=<SigmoidBackward0>), 'y': 280.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(24.4465, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(261.5535, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0043, 0.0925]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(89.2918, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(671.7082, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.3660]], grad_fn=<SigmoidBackward0>), 'y': 761.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(24.5938, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(882.5938, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0040, 0.5066]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(23.0994, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(658.9006, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.3574]], grad_fn=<SigmoidBackward0>), 'y': 682.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(26.1409, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(622.8591, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.3335]], grad_fn=<SigmoidBackward0>), 'y': 649.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(27.1542, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(371.8458, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.1661]], grad_fn=<SigmoidBackward0>), 'y': 399.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(59.1255, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(564.1255, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0040, 0.2943]], grad_fn=<SigmoidBackward0>), 'y': 504.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(70.6619, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(670.6619, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.3653]], grad_fn=<SigmoidBackward0>), 'y': 599.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(118.4219, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1142.4219, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0030, 0.6799]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(14.8315, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(454.8315, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.2214]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(121.4464, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(996.4464, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0043, 0.5824]], grad_fn=<SigmoidBackward0>), 'y': 874.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(82.0397, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(341.9603, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0037, 0.1462]], grad_fn=<SigmoidBackward0>), 'y': 424.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(128.2112, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(635.7888, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.3420]], grad_fn=<SigmoidBackward0>), 'y': 764.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(16.2906, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(248.2906, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0040, 0.0837]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(191.1599, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(809.8401, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0038, 0.4581]], grad_fn=<SigmoidBackward0>), 'y': 1001.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.3486, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(257.3486, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0045, 0.0897]], grad_fn=<SigmoidBackward0>), 'y': 194.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(156.5203, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(546.4797, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0038, 0.2825]], grad_fn=<SigmoidBackward0>), 'y': 703.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(41.4794, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(223.5206, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0046, 0.0671]], grad_fn=<SigmoidBackward0>), 'y': 265.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(193.6341, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(798.3659, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0037, 0.4504]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(38.9651, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(618.0349, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0035, 0.3302]], grad_fn=<SigmoidBackward0>), 'y': 657.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(30.9708, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(317.9708, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0043, 0.1301]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.8940, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(419.8940, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0039, 0.1981]], grad_fn=<SigmoidBackward0>), 'y': 405.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(84.6602, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1171.6602, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0040, 0.6993]], grad_fn=<SigmoidBackward0>), 'y': 1086.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(40.7822, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1052.2178, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0041, 0.6196]], grad_fn=<SigmoidBackward0>), 'y': 1093.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(204.6933, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(343.6933, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0042, 0.1473]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(178.3476, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(921.3476, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0033, 0.5325]], grad_fn=<SigmoidBackward0>), 'y': 742.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(68.8694, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(444.8694, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0039, 0.2147]], grad_fn=<SigmoidBackward0>), 'y': 375.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.9245, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(504.9245, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.2548]], grad_fn=<SigmoidBackward0>), 'y': 500.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(66.6091, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(967.6091, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0042, 0.5632]], grad_fn=<SigmoidBackward0>), 'y': 900.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(44.4839, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(393.4839, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.1805]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(153.6691, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(751.3309, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0041, 0.4190]], grad_fn=<SigmoidBackward0>), 'y': 905.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(167.1711, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(775.8289, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0041, 0.4354]], grad_fn=<SigmoidBackward0>), 'y': 943.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(168.1331, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(304.8669, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0035, 0.1214]], grad_fn=<SigmoidBackward0>), 'y': 473.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.0667, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(265.9333, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0038, 0.0955]], grad_fn=<SigmoidBackward0>), 'y': 279.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(217.4031, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(754.5969, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.4212]], grad_fn=<SigmoidBackward0>), 'y': 972.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(44.3585, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(346.6415, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.1493]], grad_fn=<SigmoidBackward0>), 'y': 391.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(79.0845, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(252.0845, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0044, 0.0862]], grad_fn=<SigmoidBackward0>), 'y': 172.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(64.6508, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(313.6508, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0042, 0.1272]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(38.7309, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(400.2691, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.1850]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(85.7105, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(334.7105, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0042, 0.1413]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(34.7726, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(273.7726, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0042, 0.1007]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(52.9702, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(297.9702, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0043, 0.1168]], grad_fn=<SigmoidBackward0>), 'y': 244.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(1.5619, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(755.4381, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0041, 0.4218]], grad_fn=<SigmoidBackward0>), 'y': 757.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(51.9734, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(953.9734, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.5541]], grad_fn=<SigmoidBackward0>), 'y': 901.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(141.2112, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(872.7888, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0040, 0.5000]], grad_fn=<SigmoidBackward0>), 'y': 1014.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(30.7167, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(585.2833, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.3084]], grad_fn=<SigmoidBackward0>), 'y': 616.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(33.7333, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(554.7333, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.2880]], grad_fn=<SigmoidBackward0>), 'y': 520.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(162.7708, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1039.7708, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0042, 0.6113]], grad_fn=<SigmoidBackward0>), 'y': 876.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(117.7945, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(693.7945, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0041, 0.3807]], grad_fn=<SigmoidBackward0>), 'y': 575.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.3525, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(971.3525, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.5657]], grad_fn=<SigmoidBackward0>), 'y': 967.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(45.7749, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(478.2251, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0040, 0.2370]], grad_fn=<SigmoidBackward0>), 'y': 524.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(124.0682, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(276.0682, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0044, 0.1022]], grad_fn=<SigmoidBackward0>), 'y': 151.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.4641, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(897.5359, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0042, 0.5165]], grad_fn=<SigmoidBackward0>), 'y': 960.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(150.9424, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(914.0576, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0041, 0.5275]], grad_fn=<SigmoidBackward0>), 'y': 1065.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(111.8314, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(255.8314, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0042, 0.0887]], grad_fn=<SigmoidBackward0>), 'y': 143.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(60.1125, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(634.8875, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.3414]], grad_fn=<SigmoidBackward0>), 'y': 695.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(87.6027, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(823.3973, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.4671]], grad_fn=<SigmoidBackward0>), 'y': 911.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(11.0559, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(907.9441, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.5235]], grad_fn=<SigmoidBackward0>), 'y': 919.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(24.3608, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1086.3608, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.6424]], grad_fn=<SigmoidBackward0>), 'y': 1061.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(72.7412, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(359.7412, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0042, 0.1580]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(195.2874, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1136.2874, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.6757]], grad_fn=<SigmoidBackward0>), 'y': 940.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(382.2744, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(510.2744, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0041, 0.2583]], grad_fn=<SigmoidBackward0>), 'y':
127.50000000000001}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(97.8743, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1014.8743, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.5948]], grad_fn=<SigmoidBackward0>), 'y': 916.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(30.3798, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(343.3798, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0043, 0.1471]], grad_fn=<SigmoidBackward0>), 'y': 312.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(12.7707, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(495.2293, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.2483]], grad_fn=<SigmoidBackward0>), 'y': 508.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(44.3295, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(465.6705, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.2286]], grad_fn=<SigmoidBackward0>), 'y': 510.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(67.9021, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(457.9021, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0041, 0.2234]], grad_fn=<SigmoidBackward0>), 'y': 389.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(154.9600, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(307.9600, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0042, 0.1235]], grad_fn=<SigmoidBackward0>), 'y': 152.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(16.9309, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(365.9309, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0038, 0.1621]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.2009, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(399.7991, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.1847]], grad_fn=<SigmoidBackward0>), 'y': 462.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(44.3351, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(567.6649, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.2966]], grad_fn=<SigmoidBackward0>), 'y': 612.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(70.8643, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(670.1357, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0032, 0.3650]], grad_fn=<SigmoidBackward0>), 'y': 741.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(123.0840, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(740.9160, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0044, 0.4121]], grad_fn=<SigmoidBackward0>), 'y': 864.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(69.7811, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(967.7811, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0040, 0.5634]], grad_fn=<SigmoidBackward0>), 'y': 897.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(92.1668, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(497.8332, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.2501]], grad_fn=<SigmoidBackward0>), 'y': 590.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(22.3281, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1006.6719, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.5893]], grad_fn=<SigmoidBackward0>), 'y': 1029.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(179.5817, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(941.4183, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.5458]], grad_fn=<SigmoidBackward0>), 'y': 1121.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(11.1688, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(573.1688, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.3003]], grad_fn=<SigmoidBackward0>), 'y': 561.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(131.1267, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(957.1267, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0039, 0.5563]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(210.1096, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(424.1096, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0042, 0.2009]], grad_fn=<SigmoidBackward0>), 'y': 213.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(2.0619, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(566.0619, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0035, 0.2956]], grad_fn=<SigmoidBackward0>), 'y': 563.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(147.3167, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1054.3167, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.6211]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(73.1108, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1162.1108, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.6929]], grad_fn=<SigmoidBackward0>), 'y': 1088.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(33.9801, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(958.0199, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0035, 0.5569]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(40.7698, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(279.7698, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.1047]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(119.2424, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(954.7576, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.5547]], grad_fn=<SigmoidBackward0>), 'y': 1074.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(44.7908, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(462.2092, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.2263]], grad_fn=<SigmoidBackward0>), 'y': 507.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(87.9682, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(237.9682, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0042, 0.0768]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(132.3770, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(870.3770, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0033, 0.4985]], grad_fn=<SigmoidBackward0>), 'y': 737.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(30.4470, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(254.4470, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0038, 0.0878]], grad_fn=<SigmoidBackward0>), 'y': 223.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(22.8910, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(914.1090, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.5276]], grad_fn=<SigmoidBackward0>), 'y': 937.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(15.9435, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(813.0565, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.4602]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.8434, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(346.8434, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0041, 0.1494]], grad_fn=<SigmoidBackward0>), 'y': 345.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(90.7644, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(948.7644, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0038, 0.5507]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(27.0162, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(586.9838, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.3095]], grad_fn=<SigmoidBackward0>), 'y': 614.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(69.3022, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(318.3022, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.1304]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(90.2128, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(407.7872, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0040, 0.1900]], grad_fn=<SigmoidBackward0>), 'y': 498.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(17.5891, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(293.4109, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0043, 0.1138]], grad_fn=<SigmoidBackward0>), 'y': 311.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(67.0414, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(296.0414, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.1155]], grad_fn=<SigmoidBackward0>), 'y': 228.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(105.7454, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(336.2546, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.1424]], grad_fn=<SigmoidBackward0>), 'y': 442.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(70.1903, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(349.1903, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.1510]], grad_fn=<SigmoidBackward0>), 'y': 278.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(21.1286, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(428.1286, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0036, 0.2036]], grad_fn=<SigmoidBackward0>), 'y': 406.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.1743, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1059.1743, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.6243]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(102.1144, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(391.8856, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.1794]], grad_fn=<SigmoidBackward0>), 'y': 494.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.8167, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(949.1833, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.5510]], grad_fn=<SigmoidBackward0>), 'y': 981.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(2.2924, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(704.7076, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.3880]], grad_fn=<SigmoidBackward0>), 'y': 707.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(52.7299, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(270.7299, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0044, 0.0986]], grad_fn=<SigmoidBackward0>), 'y': 217.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.3602, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(907.3488, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.5231]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(110.9207, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(983.9207, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.5741]], grad_fn=<SigmoidBackward0>), 'y': 872.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(76.4327, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(982.5673, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0038, 0.5732]], grad_fn=<SigmoidBackward0>), 'y': 1059.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.1980, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(360.1980, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.1583]], grad_fn=<SigmoidBackward0>), 'y': 328.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.8919, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(733.8919, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.4075]], grad_fn=<SigmoidBackward0>), 'y': 670.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(1.9140, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(579.9140, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0041, 0.3048]], grad_fn=<SigmoidBackward0>), 'y': 577.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.1757, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(298.8243, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0041, 0.1174]], grad_fn=<SigmoidBackward0>), 'y': 302.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(71.9212, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(477.0788, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0034, 0.2363]], grad_fn=<SigmoidBackward0>), 'y': 549.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(23.7801, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(234.2199, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0041, 0.0743]], grad_fn=<SigmoidBackward0>), 'y': 258.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.2549, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(227.2549, grad_fn=<AddBackward0>), 'output':
tensor([[0.0030, 0.0042, 0.0696]], grad_fn=<SigmoidBackward0>), 'y': 168.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(177.5891, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(496.4109, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.2491]], grad_fn=<SigmoidBackward0>), 'y': 674.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(231.9416, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(784.0584, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.4409]], grad_fn=<SigmoidBackward0>), 'y': 1016.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(194.0384, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(630.9616, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0038, 0.3388]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(38.2462, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(605.7538, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.3221]], grad_fn=<SigmoidBackward0>), 'y': 644.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(156.3142, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1178.3142, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.7038]], grad_fn=<SigmoidBackward0>), 'y': 1021.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(25.3231, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(506.3231, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.2558]], grad_fn=<SigmoidBackward0>), 'y': 480.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(47.4360, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1018.4360, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.5971]], grad_fn=<SigmoidBackward0>), 'y': 970.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(98.6349, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1122.6349, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.6667]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(123.8976, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(444.1024, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.2143]], grad_fn=<SigmoidBackward0>), 'y': 568.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(26.7697, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(784.2303, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0034, 0.4410]], grad_fn=<SigmoidBackward0>), 'y': 811.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.0264, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(530.7299, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0038, 0.2720]], grad_fn=<SigmoidBackward0>), 'y': 530.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(60.2865, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(984.2865, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.5744]], grad_fn=<SigmoidBackward0>), 'y': 923.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.2718, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(599.7282, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.3180]], grad_fn=<SigmoidBackward0>), 'y': 639.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(33.7188, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(324.7188, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0039, 0.1347]], grad_fn=<SigmoidBackward0>), 'y': 290.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(25.9275, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(659.9275, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.3582]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(96.0630, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(391.9370, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0040, 0.1795]], grad_fn=<SigmoidBackward0>), 'y': 488.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(47.4716, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(743.5284, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.4139]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.2166, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(874.2166, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.5010]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(153.3352, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(838.6648, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0035, 0.4773]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(23.2092, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(963.2092, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.5604]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(22.7405, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(584.2595, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0038, 0.3077]], grad_fn=<SigmoidBackward0>), 'y': 607.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(69.0281, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(929.0281, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.5376]], grad_fn=<SigmoidBackward0>), 'y': 859.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(21.9440, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(955.9440, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0032, 0.5555]], grad_fn=<SigmoidBackward0>), 'y': 933.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.3483, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(772.6517, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.4333]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(35.7864, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(787.2136, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0038, 0.4430]], grad_fn=<SigmoidBackward0>), 'y': 823.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(109.6182, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(508.3818, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.2571]], grad_fn=<SigmoidBackward0>), 'y': 618.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(67.8497, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(472.1503, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.2330]], grad_fn=<SigmoidBackward0>), 'y': 540.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(53.7852, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(892.7852, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.5134]], grad_fn=<SigmoidBackward0>), 'y': 838.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(85.2579, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(334.2579, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.1410]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(65.7024, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(473.2976, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.2337]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(103.7968, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(252.7968, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0042, 0.0867]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(20.0391, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(579.0391, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.3042]], grad_fn=<SigmoidBackward0>), 'y': 558.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(134.8766, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1157.8766, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0029, 0.6902]], grad_fn=<SigmoidBackward0>), 'y': 1022.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(26.7037, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(939.2963, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0041, 0.5444]], grad_fn=<SigmoidBackward0>), 'y': 966.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(26.3505, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(365.6495, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.1619]], grad_fn=<SigmoidBackward0>), 'y': 392.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(9.8821, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(723.1179, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.4003]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(43.6739, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(495.3261, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.2484]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(135.3126, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1075.3126, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.6351]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(103.4008, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(724.4008, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.4011]], grad_fn=<SigmoidBackward0>), 'y': 620.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(179.5298, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(775.5298, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.4352]], grad_fn=<SigmoidBackward0>), 'y': 595.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.1382, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(792.1382, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.4463]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(37.8032, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(828.8032, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.4707]], grad_fn=<SigmoidBackward0>), 'y': 790.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(15.0431, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(838.9569, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.4775]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(107.3199, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(413.6801, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.1940]], grad_fn=<SigmoidBackward0>), 'y': 521.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(222.8700, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(834.1300, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0038, 0.4743]], grad_fn=<SigmoidBackward0>), 'y': 1057.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(103.4366, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(242.4366, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0041, 0.0798]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(48.2664, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(308.7336, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.1240]], grad_fn=<SigmoidBackward0>), 'y': 357.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(65.8216, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(785.1784, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0040, 0.4416]], grad_fn=<SigmoidBackward0>), 'y': 851.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(126.3551, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(604.6449, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0033, 0.3213]], grad_fn=<SigmoidBackward0>), 'y': 731.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(55.0854, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(982.0854, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.5729]], grad_fn=<SigmoidBackward0>), 'y': 926.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(169.3405, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(901.6595, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.5193]], grad_fn=<SigmoidBackward0>), 'y': 1071.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.0072, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1036.0072, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.6089]], grad_fn=<SigmoidBackward0>), 'y': 979.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(117.3288, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(986.6712, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.5760]], grad_fn=<SigmoidBackward0>), 'y': 1104.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(32.8544, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1097.8544, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0040, 0.6501]], grad_fn=<SigmoidBackward0>), 'y': 1064.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(190.8755, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(785.8755, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.4421]], grad_fn=<SigmoidBackward0>), 'y': 594.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(166.1149, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(851.1149, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.4856]], grad_fn=<SigmoidBackward0>), 'y': 684.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(2.9954, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(495.9954, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0038, 0.2488]], grad_fn=<SigmoidBackward0>), 'y': 492.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(61.3951, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(293.3951, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0039, 0.1138]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(68.7834, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(956.2166, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.5557]], grad_fn=<SigmoidBackward0>), 'y': 1025.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(221.7750, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(695.2250, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0036, 0.3817]], grad_fn=<SigmoidBackward0>), 'y': 917.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(61.9049, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(752.0951, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.4196]], grad_fn=<SigmoidBackward0>), 'y': 814.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(8.9675, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(325.0325, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0038, 0.1349]], grad_fn=<SigmoidBackward0>), 'y': 334.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(34.7208, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(318.7208, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0042, 0.1306]], grad_fn=<SigmoidBackward0>), 'y': 283.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(123.6117, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(930.3883, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0043, 0.5384]], grad_fn=<SigmoidBackward0>), 'y': 1054.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(107.3313, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(257.3313, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0042, 0.0897]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(69.8929, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(742.8929, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.4135]], grad_fn=<SigmoidBackward0>), 'y': 672.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(116.2194, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(998.7806, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.5840]], grad_fn=<SigmoidBackward0>), 'y': 1115.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(125.2552, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(336.2552, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0042, 0.1423]], grad_fn=<SigmoidBackward0>), 'y': 210.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(145.6110, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(915.6110, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0039, 0.5286]], grad_fn=<SigmoidBackward0>), 'y': 769.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(103.1938, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(285.1938, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0045, 0.1082]], grad_fn=<SigmoidBackward0>), 'y': 181.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(120.7971, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(958.7971, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.5574]], grad_fn=<SigmoidBackward0>), 'y': 837.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(27.8911, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(399.8911, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.1848]], grad_fn=<SigmoidBackward0>), 'y': 371.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.4097, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(419.5903, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.1979]], grad_fn=<SigmoidBackward0>), 'y': 433.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(109.3633, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(979.6367, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.5713]], grad_fn=<SigmoidBackward0>), 'y': 1089.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(44.4594, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(440.5406, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0038, 0.2119]], grad_fn=<SigmoidBackward0>), 'y': 485.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(63.3344, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(401.6656, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0033, 0.1860]], grad_fn=<SigmoidBackward0>), 'y': 465.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(12.5132, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1006.4868, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.5892]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(35.6153, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(395.3847, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.1818]], grad_fn=<SigmoidBackward0>), 'y': 431.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(98.2147, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(273.2147, grad_fn=<AddBackward0>), 'output':
tensor([[0.0032, 0.0046, 0.1002]], grad_fn=<SigmoidBackward0>), 'y': 174.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(168.9733, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(802.9733, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.4535]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(144.2354, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(293.2354, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0042, 0.1136]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(151.7972, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(943.7972, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.5474]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(87.9425, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(368.9425, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.1642]], grad_fn=<SigmoidBackward0>), 'y': 280.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(55.7823, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(342.7823, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0041, 0.1467]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(59.0322, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(821.0322, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.4656]], grad_fn=<SigmoidBackward0>), 'y': 761.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(73.0969, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(931.0969, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0038, 0.5389]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.3613, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(642.6387, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.3466]], grad_fn=<SigmoidBackward0>), 'y': 682.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(109.1619, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(539.8381, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.2781]], grad_fn=<SigmoidBackward0>), 'y': 649.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(110.9409, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(288.0591, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.1102]], grad_fn=<SigmoidBackward0>), 'y': 399.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(113.3957, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(390.6043, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.1786]], grad_fn=<SigmoidBackward0>), 'y': 504.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(148.3073, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(450.6927, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.2187]], grad_fn=<SigmoidBackward0>), 'y': 599.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(119.7188, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(903.2812, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0028, 0.5204]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(81.2828, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(357.7172, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.1567]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(40.0977, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(915.0977, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0041, 0.5282]], grad_fn=<SigmoidBackward0>), 'y': 874.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(73.3265, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(350.6735, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0035, 0.1520]], grad_fn=<SigmoidBackward0>), 'y': 424.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(51.8948, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(712.1052, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.3929]], grad_fn=<SigmoidBackward0>), 'y': 764.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(70.7803, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(302.7803, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0038, 0.1200]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(38.7979, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1040.7979, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.6121]], grad_fn=<SigmoidBackward0>), 'y': 1001.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(147.4238, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(342.4238, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0042, 0.1464]], grad_fn=<SigmoidBackward0>), 'y': 194.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(53.8463, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(757.8463, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0036, 0.4234]], grad_fn=<SigmoidBackward0>), 'y': 703.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.7314, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(269.7314, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0043, 0.0980]], grad_fn=<SigmoidBackward0>), 'y': 265.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(65.3307, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(926.6693, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.5360]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(24.5176, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(682.5176, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0033, 0.3732]], grad_fn=<SigmoidBackward0>), 'y': 657.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(10.6487, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(297.6487, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0040, 0.1166]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.3293, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(348.6707, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.1506]], grad_fn=<SigmoidBackward0>), 'y': 405.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(67.2990, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1018.7010, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.5973]], grad_fn=<SigmoidBackward0>), 'y': 1086.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(201.3473, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(891.6527, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.5126]], grad_fn=<SigmoidBackward0>), 'y': 1093.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(130.7758, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(269.7758, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0040, 0.0980]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(28.3190, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(771.3190, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0031, 0.4325]], grad_fn=<SigmoidBackward0>), 'y': 742.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(23.1906, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(351.8094, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.1527]], grad_fn=<SigmoidBackward0>), 'y': 375.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.5594, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(437.4406, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.2098]], grad_fn=<SigmoidBackward0>), 'y': 500.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(24.1586, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(925.1586, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.5349]], grad_fn=<SigmoidBackward0>), 'y': 900.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(57.6870, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(406.6870, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.1893]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(66.4626, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(838.5374, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.4772]], grad_fn=<SigmoidBackward0>), 'y': 905.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.3292, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(911.6708, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.5260]], grad_fn=<SigmoidBackward0>), 'y': 943.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.0281, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(414.9719, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0033, 0.1949]], grad_fn=<SigmoidBackward0>), 'y': 473.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(87.1751, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(367.1751, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.1630]], grad_fn=<SigmoidBackward0>), 'y': 279.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(48.9335, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1021.9335, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.5995]], grad_fn=<SigmoidBackward0>), 'y': 972.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(101.9079, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(493.9079, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.2475]], grad_fn=<SigmoidBackward0>), 'y': 391.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(130.5231, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(303.5231, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0042, 0.1205]], grad_fn=<SigmoidBackward0>), 'y': 172.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(103.6458, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(352.6458, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.1533]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(6.6162, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(446.6162, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.2159]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.7095, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(307.7095, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.1233]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.8992, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(233.1008, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.0736]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(8.6551, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(235.3449, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0041, 0.0751]], grad_fn=<SigmoidBackward0>), 'y': 244.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(180.0929, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(576.9071, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0039, 0.3028]], grad_fn=<SigmoidBackward0>), 'y': 757.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(170.3195, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(730.6805, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.4053]], grad_fn=<SigmoidBackward0>), 'y': 901.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(320.9267, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(693.0733, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.3803]], grad_fn=<SigmoidBackward0>), 'y': 1014.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(148.1967, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(467.8033, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.2301]], grad_fn=<SigmoidBackward0>), 'y': 616.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(73.5729, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(446.4271, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.2158]], grad_fn=<SigmoidBackward0>), 'y': 520.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(55.9073, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(932.9073, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0040, 0.5401]], grad_fn=<SigmoidBackward0>), 'y': 876.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(67.0587, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(643.0587, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0039, 0.3469]], grad_fn=<SigmoidBackward0>), 'y': 575.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(6.6230, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(960.3770, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.5584]], grad_fn=<SigmoidBackward0>), 'y': 967.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(26.6393, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(551.6393, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0038, 0.2860]], grad_fn=<SigmoidBackward0>), 'y': 524.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(166.9396, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(318.9396, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.1308]], grad_fn=<SigmoidBackward0>), 'y': 151.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(85.5627, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1046.5627, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0040, 0.6159]], grad_fn=<SigmoidBackward0>), 'y': 960.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.1517, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1051.8483, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.6194]], grad_fn=<SigmoidBackward0>), 'y': 1065.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(149.1158, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(293.1158, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.1136]], grad_fn=<SigmoidBackward0>), 'y': 143.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(45.7661, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(741.7661, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.4127]], grad_fn=<SigmoidBackward0>), 'y': 695.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(51.7487, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(859.2513, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.4910]], grad_fn=<SigmoidBackward0>), 'y': 911.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(25.9972, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(893.0028, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.5135]], grad_fn=<SigmoidBackward0>), 'y': 919.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(34.7919, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1026.2081, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.6023]], grad_fn=<SigmoidBackward0>), 'y': 1061.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(30.7708, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(317.7708, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0040, 0.1300]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(123.8696, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1064.8696, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.6281]], grad_fn=<SigmoidBackward0>), 'y': 940.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(315.0850, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(443.0850, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0039, 0.2136]], grad_fn=<SigmoidBackward0>), 'y':
127.50000000000001}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(30.2624, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(947.2624, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.5497]], grad_fn=<SigmoidBackward0>), 'y': 916.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.0098, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(308.9902, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0041, 0.1242]], grad_fn=<SigmoidBackward0>), 'y': 312.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(24.3771, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(483.6229, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.2406]], grad_fn=<SigmoidBackward0>), 'y': 508.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(40.7689, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(469.2311, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.2310]], grad_fn=<SigmoidBackward0>), 'y': 510.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(69.1205, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(459.1205, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0039, 0.2243]], grad_fn=<SigmoidBackward0>), 'y': 389.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(159.5903, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(312.5903, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.1266]], grad_fn=<SigmoidBackward0>), 'y': 152.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(37.8235, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(386.8235, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.1761]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.4426, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(443.5574, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.2139]], grad_fn=<SigmoidBackward0>), 'y': 462.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(32.8468, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(645.8468, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.3488]], grad_fn=<SigmoidBackward0>), 'y': 612.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(27.4005, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(713.5995, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.3940]], grad_fn=<SigmoidBackward0>), 'y': 741.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(121.6052, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(742.3948, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0042, 0.4131]], grad_fn=<SigmoidBackward0>), 'y': 864.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(60.9729, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(958.9729, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.5575]], grad_fn=<SigmoidBackward0>), 'y': 897.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(112.4381, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(477.5619, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.2366]], grad_fn=<SigmoidBackward0>), 'y': 590.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(70.2722, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(958.7278, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.5574]], grad_fn=<SigmoidBackward0>), 'y': 1029.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(247.4899, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(873.5101, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.5005]], grad_fn=<SigmoidBackward0>), 'y': 1121.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.4080, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(498.5920, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0033, 0.2506]], grad_fn=<SigmoidBackward0>), 'y': 561.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(79.7555, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(905.7555, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.5220]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(176.2846, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(390.2846, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0040, 0.1784]], grad_fn=<SigmoidBackward0>), 'y': 213.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(7.8836, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(555.1164, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0033, 0.2883]], grad_fn=<SigmoidBackward0>), 'y': 563.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(195.0968, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1102.0968, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.6529]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(165.4966, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1254.4966, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.7545]], grad_fn=<SigmoidBackward0>), 'y': 1088.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(137.5498, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1130.5498, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0034, 0.6719]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(109.1401, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(348.1401, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.1503]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(42.0553, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1117.0553, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.6629]], grad_fn=<SigmoidBackward0>), 'y': 1074.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(54.2512, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(562.2512, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.2930]], grad_fn=<SigmoidBackward0>), 'y': 507.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(92.9183, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(242.9183, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.0801]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(73.0573, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(811.0573, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0031, 0.4589]], grad_fn=<SigmoidBackward0>), 'y': 737.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(6.3252, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(216.6748, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0036, 0.0626]], grad_fn=<SigmoidBackward0>), 'y': 223.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(199.6074, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(737.3926, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.4098]], grad_fn=<SigmoidBackward0>), 'y': 937.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(221.0857, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(607.9143, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.3235]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(103.9290, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(241.0710, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0039, 0.0789]], grad_fn=<SigmoidBackward0>), 'y': 345.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(201.1728, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(655.8272, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.3554]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(198.4994, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(415.5006, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0035, 0.1952]], grad_fn=<SigmoidBackward0>), 'y': 614.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(14.0971, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(233.9029, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.0741]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(178.3308, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(319.6692, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0039, 0.1313]], grad_fn=<SigmoidBackward0>), 'y': 498.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(68.4714, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(242.5286, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0041, 0.0799]], grad_fn=<SigmoidBackward0>), 'y': 311.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(20.9665, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(249.9665, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.0848]], grad_fn=<SigmoidBackward0>), 'y': 228.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(140.8901, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(301.1099, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.1189]], grad_fn=<SigmoidBackward0>), 'y': 442.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(29.6140, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(308.6140, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.1239]], grad_fn=<SigmoidBackward0>), 'y': 278.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(7.6835, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(398.3165, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.1837]], grad_fn=<SigmoidBackward0>), 'y': 406.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(40.1011, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1060.1011, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.6250]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(64.9453, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(429.0547, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0040, 0.2042]], grad_fn=<SigmoidBackward0>), 'y': 494.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(63.5402, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1045.5402, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.6152]], grad_fn=<SigmoidBackward0>), 'y': 981.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(86.9969, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(794.9969, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.4482]], grad_fn=<SigmoidBackward0>), 'y': 707.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(57.1697, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(275.1697, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0042, 0.1016]], grad_fn=<SigmoidBackward0>), 'y': 217.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(33.7740, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(872.2260, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.4997]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(70.2220, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(943.2220, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0038, 0.5470]], grad_fn=<SigmoidBackward0>), 'y': 872.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(101.9956, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(957.0044, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.5562]], grad_fn=<SigmoidBackward0>), 'y': 1059.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(9.2237, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(338.2237, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.1437]], grad_fn=<SigmoidBackward0>), 'y': 328.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(14.8008, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(685.8008, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.3754]], grad_fn=<SigmoidBackward0>), 'y': 670.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.3240, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(547.6760, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0040, 0.2833]], grad_fn=<SigmoidBackward0>), 'y': 577.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.8738, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(298.1262, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0040, 0.1169]], grad_fn=<SigmoidBackward0>), 'y': 302.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(27.9599, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(521.0401, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0033, 0.2656]], grad_fn=<SigmoidBackward0>), 'y': 549.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.5447, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(254.4553, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0040, 0.0878]], grad_fn=<SigmoidBackward0>), 'y': 258.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(89.0827, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(258.0827, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0041, 0.0902]], grad_fn=<SigmoidBackward0>), 'y': 168.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.9089, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(617.0911, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.3296]], grad_fn=<SigmoidBackward0>), 'y': 674.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(48.2191, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(967.7809, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.5634]], grad_fn=<SigmoidBackward0>), 'y': 1016.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(12.9888, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(838.9888, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0038, 0.4775]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(138.1145, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(783.1145, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.4403]], grad_fn=<SigmoidBackward0>), 'y': 644.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(233.3837, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1255.3837, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.7552]], grad_fn=<SigmoidBackward0>), 'y': 1021.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.2013, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(543.2013, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.2804]], grad_fn=<SigmoidBackward0>), 'y': 480.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.6182, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(989.6182, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.5779]], grad_fn=<SigmoidBackward0>), 'y': 970.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(26.5327, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1050.5327, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0028, 0.6186]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(188.6459, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(379.3541, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0038, 0.1711]], grad_fn=<SigmoidBackward0>), 'y': 568.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(187.7975, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(623.2025, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.3337]], grad_fn=<SigmoidBackward0>), 'y': 811.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(137.6546, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(392.3454, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.1798]], grad_fn=<SigmoidBackward0>), 'y': 530.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(177.1710, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(745.8290, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.4154]], grad_fn=<SigmoidBackward0>), 'y': 923.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(187.6046, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(451.3954, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.2192]], grad_fn=<SigmoidBackward0>), 'y': 639.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.2736, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(253.7264, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0038, 0.0873]], grad_fn=<SigmoidBackward0>), 'y': 290.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(85.3962, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(547.6038, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.2833]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(108.0898, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(379.9102, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.1715]], grad_fn=<SigmoidBackward0>), 'y': 488.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(21.3882, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(769.6118, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.4313]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(106.4392, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(961.4392, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.5592]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(17.9332, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1010.9332, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0034, 0.5922]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(178.2537, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1118.2537, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0033, 0.6637]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(150.0873, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(758.0873, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0038, 0.4236]], grad_fn=<SigmoidBackward0>), 'y': 607.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(192.7869, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1052.7869, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.6201]], grad_fn=<SigmoidBackward0>), 'y': 859.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(111.4066, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1045.4066, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0031, 0.6152]], grad_fn=<SigmoidBackward0>), 'y': 933.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(5.9981, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(835.9981, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.4755]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(55.4518, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(767.5482, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0037, 0.4299]], grad_fn=<SigmoidBackward0>), 'y': 823.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(165.4039, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(452.5961, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.2199]], grad_fn=<SigmoidBackward0>), 'y': 618.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(156.3994, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(383.6006, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.1739]], grad_fn=<SigmoidBackward0>), 'y': 540.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(182.7698, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(655.2302, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.3551]], grad_fn=<SigmoidBackward0>), 'y': 838.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.2616, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(243.7384, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.0807]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(186.7897, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(352.2103, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.1530]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(51.5087, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(200.5087, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.0518]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(126.4256, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(431.5744, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.2059]], grad_fn=<SigmoidBackward0>), 'y': 558.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.0295, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1008.9705, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.5909]], grad_fn=<SigmoidBackward0>), 'y': 1022.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(80.7175, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(885.2825, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0040, 0.5084]], grad_fn=<SigmoidBackward0>), 'y': 966.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.0005, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(392.5331, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0039, 0.1799]], grad_fn=<SigmoidBackward0>), 'y': 392.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(97.3894, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(831.3894, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.4725]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(47.4691, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(587.4691, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.3098]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(179.3525, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1119.3525, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0033, 0.6645]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(129.9751, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(750.9751, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.4189]], grad_fn=<SigmoidBackward0>), 'y': 620.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(177.5706, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(773.5706, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.4339]], grad_fn=<SigmoidBackward0>), 'y': 595.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(30.3202, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(764.3202, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.4278]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.6302, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(760.3698, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.4251]], grad_fn=<SigmoidBackward0>), 'y': 790.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(64.8604, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(789.1396, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.4443]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(105.1023, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(415.8977, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.1955]], grad_fn=<SigmoidBackward0>), 'y': 521.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(196.0316, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(860.9684, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0038, 0.4922]], grad_fn=<SigmoidBackward0>), 'y': 1057.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(111.7825, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(250.7825, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0040, 0.0853]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.6099, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(337.3901, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0039, 0.1431]], grad_fn=<SigmoidBackward0>), 'y': 357.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.0068, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(851.6169, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0039, 0.4859]], grad_fn=<SigmoidBackward0>), 'y': 851.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.8531, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(672.1469, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.3663]], grad_fn=<SigmoidBackward0>), 'y': 731.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(106.2861, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1033.2861, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0032, 0.6071]], grad_fn=<SigmoidBackward0>), 'y': 926.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(115.5485, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(955.4515, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0038, 0.5551]], grad_fn=<SigmoidBackward0>), 'y': 1071.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(92.9407, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1072.9407, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.6335]], grad_fn=<SigmoidBackward0>), 'y': 979.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(80.6517, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1023.3483, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.6004]], grad_fn=<SigmoidBackward0>), 'y': 1104.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.8979, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1127.8979, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0040, 0.6701]], grad_fn=<SigmoidBackward0>), 'y': 1064.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(217.9836, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(812.9836, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.4602]], grad_fn=<SigmoidBackward0>), 'y': 594.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(182.5194, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(867.5194, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.4966]], grad_fn=<SigmoidBackward0>), 'y': 684.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.0070, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(511.0070, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0038, 0.2589]], grad_fn=<SigmoidBackward0>), 'y': 492.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(63.6384, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(295.6384, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0038, 0.1153]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(51.5275, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(973.4725, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.5672]], grad_fn=<SigmoidBackward0>), 'y': 1025.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(217.3130, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(699.6870, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.3847]], grad_fn=<SigmoidBackward0>), 'y': 917.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(55.6570, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(758.3430, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.4238]], grad_fn=<SigmoidBackward0>), 'y': 814.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(9.1009, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(324.8991, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0038, 0.1348]], grad_fn=<SigmoidBackward0>), 'y': 334.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.2034, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(315.2034, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0041, 0.1283]], grad_fn=<SigmoidBackward0>), 'y': 283.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(134.9979, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(919.0021, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0043, 0.5308]], grad_fn=<SigmoidBackward0>), 'y': 1054.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(99.5127, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(249.5127, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.0845]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(59.8458, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(732.8458, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.4068]], grad_fn=<SigmoidBackward0>), 'y': 672.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(114.1306, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1000.8694, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.5854]], grad_fn=<SigmoidBackward0>), 'y': 1115.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(114.7803, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(325.7803, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0041, 0.1353]], grad_fn=<SigmoidBackward0>), 'y': 210.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(126.6726, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(896.6726, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0039, 0.5160]], grad_fn=<SigmoidBackward0>), 'y': 769.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(94.9011, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(276.9011, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0044, 0.1027]], grad_fn=<SigmoidBackward0>), 'y': 181.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(108.8970, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(946.8970, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.5495]], grad_fn=<SigmoidBackward0>), 'y': 837.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(17.8766, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(389.8766, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.1781]], grad_fn=<SigmoidBackward0>), 'y': 371.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(15.7396, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(417.2604, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.1964]], grad_fn=<SigmoidBackward0>), 'y': 433.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(119.7783, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(969.2217, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.5643]], grad_fn=<SigmoidBackward0>), 'y': 1089.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(44.5301, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(440.4699, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0038, 0.2118]], grad_fn=<SigmoidBackward0>), 'y': 485.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(63.5725, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(401.4275, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0033, 0.1858]], grad_fn=<SigmoidBackward0>), 'y': 465.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(23.3784, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(995.6216, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.5820]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.2580, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(394.7420, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.1814]], grad_fn=<SigmoidBackward0>), 'y': 431.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(88.7564, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(263.7564, grad_fn=<AddBackward0>), 'output':
tensor([[0.0031, 0.0045, 0.0940]], grad_fn=<SigmoidBackward0>), 'y': 174.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(158.0314, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(792.0314, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.4462]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(136.3474, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(285.3474, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.1084]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(141.9072, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(933.9072, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.5408]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(82.9230, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(363.9230, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.1608]], grad_fn=<SigmoidBackward0>), 'y': 280.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(49.8102, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(336.8102, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0040, 0.1427]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(50.1470, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(812.1470, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.4596]], grad_fn=<SigmoidBackward0>), 'y': 761.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(59.6257, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(917.6257, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.5299]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(45.2203, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(636.7797, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.3427]], grad_fn=<SigmoidBackward0>), 'y': 682.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(106.4772, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(542.5228, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.2799]], grad_fn=<SigmoidBackward0>), 'y': 649.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(108.8285, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(290.1715, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.1117]], grad_fn=<SigmoidBackward0>), 'y': 399.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(112.5281, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(391.4719, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.1792]], grad_fn=<SigmoidBackward0>), 'y': 504.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(145.2139, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(453.7861, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.2207]], grad_fn=<SigmoidBackward0>), 'y': 599.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(103.4898, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(919.5102, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0028, 0.5313]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(71.9857, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(367.0143, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.1629]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(35.4199, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(910.4199, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0040, 0.5251]], grad_fn=<SigmoidBackward0>), 'y': 874.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.6084, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(361.3916, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.1591]], grad_fn=<SigmoidBackward0>), 'y': 424.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(45.8898, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(718.1102, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.3969]], grad_fn=<SigmoidBackward0>), 'y': 764.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(72.5780, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(304.5780, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.1212]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(49.7107, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1051.7107, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.6193]], grad_fn=<SigmoidBackward0>), 'y': 1001.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(151.1248, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(346.1248, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0042, 0.1489]], grad_fn=<SigmoidBackward0>), 'y': 194.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.0820, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(760.0820, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.4249]], grad_fn=<SigmoidBackward0>), 'y': 703.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.4149, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(269.4149, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0043, 0.0978]], grad_fn=<SigmoidBackward0>), 'y': 265.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(55.6651, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(936.3349, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0034, 0.5424]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(34.2175, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(692.2175, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.3797]], grad_fn=<SigmoidBackward0>), 'y': 657.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.3724, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(300.3724, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0040, 0.1184]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.7890, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(365.2110, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.1617]], grad_fn=<SigmoidBackward0>), 'y': 405.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(45.4700, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1040.5300, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.6119]], grad_fn=<SigmoidBackward0>), 'y': 1086.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(181.3008, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(911.6992, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0038, 0.5260]], grad_fn=<SigmoidBackward0>), 'y': 1093.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(132.3504, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(271.3504, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0039, 0.0991]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(52.9917, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(795.9917, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0030, 0.4489]], grad_fn=<SigmoidBackward0>), 'y': 742.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.5067, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(361.4933, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.1592]], grad_fn=<SigmoidBackward0>), 'y': 375.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(46.7741, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(453.2259, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.2203]], grad_fn=<SigmoidBackward0>), 'y': 500.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.4257, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(937.4257, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.5431]], grad_fn=<SigmoidBackward0>), 'y': 900.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(66.7339, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(415.7339, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.1954]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.8875, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(865.1125, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.4949]], grad_fn=<SigmoidBackward0>), 'y': 905.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(16.1398, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(926.8602, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0039, 0.5361]], grad_fn=<SigmoidBackward0>), 'y': 943.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(34.5641, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(438.4359, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.2105]], grad_fn=<SigmoidBackward0>), 'y': 473.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(96.2538, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(376.2538, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.1690]], grad_fn=<SigmoidBackward0>), 'y': 279.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(69.4475, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1042.4475, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.6132]], grad_fn=<SigmoidBackward0>), 'y': 972.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(125.4764, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(517.4764, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.2632]], grad_fn=<SigmoidBackward0>), 'y': 391.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(135.2144, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(308.2144, grad_fn=<AddBackward0>), 'output':
tensor([[0.0029, 0.0041, 0.1236]], grad_fn=<SigmoidBackward0>), 'y': 172.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(111.9239, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(360.9239, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.1588]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(33.0600, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(473.0600, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.2336]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(64.6350, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(313.6350, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.1273]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(2.0643, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(235.9357, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.0755]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(6.6485, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(237.3515, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0040, 0.0764]], grad_fn=<SigmoidBackward0>), 'y': 244.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(165.4529, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(591.5471, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0038, 0.3126]], grad_fn=<SigmoidBackward0>), 'y': 757.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(156.2084, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(744.7916, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.4147]], grad_fn=<SigmoidBackward0>), 'y': 901.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(299.5334, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(714.4666, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0037, 0.3945]], grad_fn=<SigmoidBackward0>), 'y': 1014.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(129.0140, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(486.9860, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.2428]], grad_fn=<SigmoidBackward0>), 'y': 616.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.3381, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(463.6619, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.2273]], grad_fn=<SigmoidBackward0>), 'y': 520.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(61.2873, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(938.2873, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.5437]], grad_fn=<SigmoidBackward0>), 'y': 876.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(90.8390, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(666.8390, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0039, 0.3627]], grad_fn=<SigmoidBackward0>), 'y': 575.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(15.4703, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(983.4703, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.5738]], grad_fn=<SigmoidBackward0>), 'y': 967.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(8.0781, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(533.0781, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.2736]], grad_fn=<SigmoidBackward0>), 'y': 524.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(128.2548, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(280.2548, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0041, 0.1050]], grad_fn=<SigmoidBackward0>), 'y': 151.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(34.9655, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(925.0345, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0040, 0.5349]], grad_fn=<SigmoidBackward0>), 'y': 960.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(105.7002, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(959.2998, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0039, 0.5577]], grad_fn=<SigmoidBackward0>), 'y': 1065.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(114.3378, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(258.3378, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.0904]], grad_fn=<SigmoidBackward0>), 'y': 143.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(21.5337, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(673.4663, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0034, 0.3672]], grad_fn=<SigmoidBackward0>), 'y': 695.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(53.9666, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(857.0334, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.4896]], grad_fn=<SigmoidBackward0>), 'y': 911.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(35.6832, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(955.6832, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.5553]], grad_fn=<SigmoidBackward0>), 'y': 919.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(26.5579, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1088.5579, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.6439]], grad_fn=<SigmoidBackward0>), 'y': 1061.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(28.0910, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(315.0910, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0039, 0.1282]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(73.4931, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1014.4931, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.5945]], grad_fn=<SigmoidBackward0>), 'y': 940.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(248.2877, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(376.2877, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0038, 0.1690]], grad_fn=<SigmoidBackward0>), 'y':
127.50000000000001}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(97.4180, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(818.5820, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.4639]], grad_fn=<SigmoidBackward0>), 'y': 916.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(42.9456, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(269.0544, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0040, 0.0975]], grad_fn=<SigmoidBackward0>), 'y': 312.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(72.0925, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(435.9075, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.2088]], grad_fn=<SigmoidBackward0>), 'y': 508.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(80.0088, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(429.9912, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.2049]], grad_fn=<SigmoidBackward0>), 'y': 510.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.7979, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(421.7979, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0038, 0.1994]], grad_fn=<SigmoidBackward0>), 'y': 389.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(133.0929, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(286.0929, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0040, 0.1089]], grad_fn=<SigmoidBackward0>), 'y': 152.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.3350, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(362.3350, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.1598]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(26.2389, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(435.7611, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.2087]], grad_fn=<SigmoidBackward0>), 'y': 462.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(16.1343, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(629.1343, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.3376]], grad_fn=<SigmoidBackward0>), 'y': 612.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(27.9093, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(713.0907, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0030, 0.3936]], grad_fn=<SigmoidBackward0>), 'y': 741.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(128.7253, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(735.2747, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0042, 0.4083]], grad_fn=<SigmoidBackward0>), 'y': 864.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(61.9090, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(959.9090, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.5581]], grad_fn=<SigmoidBackward0>), 'y': 897.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(94.5844, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(495.4156, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.2485]], grad_fn=<SigmoidBackward0>), 'y': 590.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(44.5582, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(984.4418, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.5745]], grad_fn=<SigmoidBackward0>), 'y': 1029.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(213.8891, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(907.1109, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0038, 0.5229]], grad_fn=<SigmoidBackward0>), 'y': 1121.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(27.3346, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(533.6654, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.2740]], grad_fn=<SigmoidBackward0>), 'y': 561.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(113.7374, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(939.7374, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0037, 0.5447]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(197.4580, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(411.4580, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0040, 0.1925]], grad_fn=<SigmoidBackward0>), 'y': 213.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(43.2438, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(607.2438, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0033, 0.3231]], grad_fn=<SigmoidBackward0>), 'y': 563.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(205.7141, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1112.7141, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.6600]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(141.0870, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1230.0870, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.7383]], grad_fn=<SigmoidBackward0>), 'y': 1088.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(69.9832, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1062.9832, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0033, 0.6269]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.7622, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(297.7622, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.1167]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(68.3459, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1005.6541, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.5886]], grad_fn=<SigmoidBackward0>), 'y': 1074.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(16.2525, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(490.7475, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.2454]], grad_fn=<SigmoidBackward0>), 'y': 507.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(78.2786, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(228.2786, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0040, 0.0704]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(93.3270, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(831.3270, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0031, 0.4725]], grad_fn=<SigmoidBackward0>), 'y': 737.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(8.8321, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(232.8321, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0036, 0.0734]], grad_fn=<SigmoidBackward0>), 'y': 223.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(94.0934, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(842.9066, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.4802]], grad_fn=<SigmoidBackward0>), 'y': 937.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(99.4136, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(729.5864, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.4046]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(45.3530, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(299.6470, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0038, 0.1180]], grad_fn=<SigmoidBackward0>), 'y': 345.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(14.3835, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(842.6165, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.4800]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(23.7893, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(590.2107, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.3117]], grad_fn=<SigmoidBackward0>), 'y': 614.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(77.0900, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(326.0900, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.1356]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(10.2503, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(487.7497, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0038, 0.2434]], grad_fn=<SigmoidBackward0>), 'y': 498.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(45.5801, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(357.5801, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0040, 0.1566]], grad_fn=<SigmoidBackward0>), 'y': 311.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(135.2527, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(364.2527, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.1610]], grad_fn=<SigmoidBackward0>), 'y': 228.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(9.6858, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(452.6858, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.2200]], grad_fn=<SigmoidBackward0>), 'y': 442.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(151.2089, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(430.2089, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.2050]], grad_fn=<SigmoidBackward0>), 'y': 278.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(130.0911, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(537.0911, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.2763]], grad_fn=<SigmoidBackward0>), 'y': 406.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(145.1483, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1165.1483, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.6950]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(27.1215, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(466.8785, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.2294]], grad_fn=<SigmoidBackward0>), 'y': 494.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(52.9258, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1034.9258, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.6082]], grad_fn=<SigmoidBackward0>), 'y': 981.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(25.3259, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(733.3259, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.4071]], grad_fn=<SigmoidBackward0>), 'y': 707.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(17.7992, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(235.7992, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0041, 0.0754]], grad_fn=<SigmoidBackward0>), 'y': 217.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(170.5632, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(735.4368, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.4085]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(109.6545, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(762.3455, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.4264]], grad_fn=<SigmoidBackward0>), 'y': 872.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(247.7791, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(811.2209, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.4590]], grad_fn=<SigmoidBackward0>), 'y': 1059.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(53.7203, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(274.2797, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.1011]], grad_fn=<SigmoidBackward0>), 'y': 328.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(80.2383, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(589.7617, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.3114]], grad_fn=<SigmoidBackward0>), 'y': 670.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(46.8809, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(530.1191, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0039, 0.2716]], grad_fn=<SigmoidBackward0>), 'y': 577.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(14.1749, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(317.1749, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0039, 0.1296]], grad_fn=<SigmoidBackward0>), 'y': 302.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(57.8590, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(607.8590, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0032, 0.3235]], grad_fn=<SigmoidBackward0>), 'y': 549.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(17.7189, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(276.7189, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0038, 0.1027]], grad_fn=<SigmoidBackward0>), 'y': 258.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(104.1732, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(273.1732, grad_fn=<AddBackward0>), 'output':
tensor([[0.0027, 0.0040, 0.1003]], grad_fn=<SigmoidBackward0>), 'y': 168.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(11.8328, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(662.1672, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.3597]], grad_fn=<SigmoidBackward0>), 'y': 674.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.5471, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(997.4529, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.5832]], grad_fn=<SigmoidBackward0>), 'y': 1016.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(16.3004, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(842.3004, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0036, 0.4797]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(127.3758, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(772.3758, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.4332]], grad_fn=<SigmoidBackward0>), 'y': 644.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(232.2480, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1254.2480, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.7544]], grad_fn=<SigmoidBackward0>), 'y': 1021.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.2758, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(517.2758, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0032, 0.2631]], grad_fn=<SigmoidBackward0>), 'y': 480.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(17.8154, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(952.1846, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.5530]], grad_fn=<SigmoidBackward0>), 'y': 970.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(52.2004, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1076.2004, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0027, 0.6357]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(168.0220, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(399.9780, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.1849]], grad_fn=<SigmoidBackward0>), 'y': 568.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(120.2162, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(690.7838, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0032, 0.3788]], grad_fn=<SigmoidBackward0>), 'y': 811.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.0847, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(467.9153, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.2302]], grad_fn=<SigmoidBackward0>), 'y': 530.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(23.4984, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(899.5016, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.5179]], grad_fn=<SigmoidBackward0>), 'y': 923.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(55.6866, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(583.3134, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.3071]], grad_fn=<SigmoidBackward0>), 'y': 639.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(37.5045, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(328.5045, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.1372]], grad_fn=<SigmoidBackward0>), 'y': 290.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(108.4870, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(742.4870, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.4132]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(5.1316, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(494.1316, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.2476]], grad_fn=<SigmoidBackward0>), 'y': 488.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(84.7753, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(876.7753, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.5027]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(95.2074, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(950.2074, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.5517]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(94.0344, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(897.9656, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.5169]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(32.7039, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(972.7039, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0031, 0.5667]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(38.2064, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(568.7936, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0036, 0.2974]], grad_fn=<SigmoidBackward0>), 'y': 607.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(20.7902, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(880.7902, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.5054]], grad_fn=<SigmoidBackward0>), 'y': 859.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.9178, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(876.0822, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0030, 0.5023]], grad_fn=<SigmoidBackward0>), 'y': 933.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(109.5161, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(719.4839, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.3979]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.1292, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(766.8708, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.4295]], grad_fn=<SigmoidBackward0>), 'y': 823.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(109.6241, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(508.3759, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.2571]], grad_fn=<SigmoidBackward0>), 'y': 618.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.9890, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(500.0110, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.2516]], grad_fn=<SigmoidBackward0>), 'y': 540.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(93.1369, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(932.1369, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.5397]], grad_fn=<SigmoidBackward0>), 'y': 838.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(101.3514, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(350.3514, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0038, 0.1518]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.1201, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(535.8799, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.2755]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(122.5194, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(271.5194, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.0992]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(108.2720, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(667.2720, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.3631]], grad_fn=<SigmoidBackward0>), 'y': 558.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(253.5375, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1276.5375, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0027, 0.7693]], grad_fn=<SigmoidBackward0>), 'y': 1022.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(112.1016, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1079.1016, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0038, 0.6376]], grad_fn=<SigmoidBackward0>), 'y': 966.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(20.4791, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(413.4791, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.1939]], grad_fn=<SigmoidBackward0>), 'y': 392.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(16.8807, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(750.8807, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.4188]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(101.6192, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(437.3808, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.2098]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(53.2944, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(885.7056, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0031, 0.5087]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(107.0516, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(512.9484, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.2602]], grad_fn=<SigmoidBackward0>), 'y': 620.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(28.6307, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(566.3693, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.2958]], grad_fn=<SigmoidBackward0>), 'y': 595.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(98.3189, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(634.6811, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.3414]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(28.1252, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(761.8748, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.4261]], grad_fn=<SigmoidBackward0>), 'y': 790.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(53.1673, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(908.1673, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.5237]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(14.0788, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(536.0788, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.2756]], grad_fn=<SigmoidBackward0>), 'y': 521.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.6923, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1053.3077, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0035, 0.6204]], grad_fn=<SigmoidBackward0>), 'y': 1057.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(167.9572, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(306.9572, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0038, 0.1228]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(76.8475, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(434.8475, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.2081]], grad_fn=<SigmoidBackward0>), 'y': 357.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(152.4867, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1004.4867, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0037, 0.5879]], grad_fn=<SigmoidBackward0>), 'y': 851.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(41.8906, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(773.8906, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.4342]], grad_fn=<SigmoidBackward0>), 'y': 731.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(123.1754, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1050.1754, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0030, 0.6184]], grad_fn=<SigmoidBackward0>), 'y': 926.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(173.2386, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(897.7614, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.5167]], grad_fn=<SigmoidBackward0>), 'y': 1071.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(47.9176, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(931.0824, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0033, 0.5389]], grad_fn=<SigmoidBackward0>), 'y': 979.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(228.6686, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(875.3314, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.5018]], grad_fn=<SigmoidBackward0>), 'y': 1104.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(93.0229, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(970.9771, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.5655]], grad_fn=<SigmoidBackward0>), 'y': 1064.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(70.3911, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(665.3911, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.3618]], grad_fn=<SigmoidBackward0>), 'y': 594.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(66.4119, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(751.4119, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.4192]], grad_fn=<SigmoidBackward0>), 'y': 684.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(49.2832, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(442.7168, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.2133]], grad_fn=<SigmoidBackward0>), 'y': 492.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(44.1192, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(276.1192, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.1023]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(1.1465, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1027.1465, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.6030]], grad_fn=<SigmoidBackward0>), 'y': 1025.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(171.8638, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(745.1362, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0033, 0.4150]], grad_fn=<SigmoidBackward0>), 'y': 917.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(11.2018, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(802.7982, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.4534]], grad_fn=<SigmoidBackward0>), 'y': 814.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.7673, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(339.7673, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.1447]], grad_fn=<SigmoidBackward0>), 'y': 334.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(26.9855, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(310.9855, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0038, 0.1255]], grad_fn=<SigmoidBackward0>), 'y': 283.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(120.4143, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(933.5857, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0040, 0.5406]], grad_fn=<SigmoidBackward0>), 'y': 1054.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(84.2877, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(234.2877, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.0744]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(22.1157, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(695.1157, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.3816]], grad_fn=<SigmoidBackward0>), 'y': 672.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(146.4471, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(968.5529, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.5639]], grad_fn=<SigmoidBackward0>), 'y': 1115.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(74.0991, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(285.0991, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.1082]], grad_fn=<SigmoidBackward0>), 'y': 210.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(45.3661, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(815.3661, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.4618]], grad_fn=<SigmoidBackward0>), 'y': 769.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(57.3974, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(239.3974, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.0778]], grad_fn=<SigmoidBackward0>), 'y': 181.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(10.1469, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(848.1469, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.4837]], grad_fn=<SigmoidBackward0>), 'y': 837.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(44.5759, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(326.4241, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.1358]], grad_fn=<SigmoidBackward0>), 'y': 371.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(61.0389, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(371.9611, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.1662]], grad_fn=<SigmoidBackward0>), 'y': 433.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(143.9714, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(945.0286, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.5482]], grad_fn=<SigmoidBackward0>), 'y': 1089.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(65.6176, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(419.3824, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.1978]], grad_fn=<SigmoidBackward0>), 'y': 485.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(80.5350, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(384.4650, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0030, 0.1745]], grad_fn=<SigmoidBackward0>), 'y': 465.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(21.2518, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(997.7482, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.5834]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(37.8254, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(393.1746, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.1803]], grad_fn=<SigmoidBackward0>), 'y': 431.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(82.4082, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(257.4082, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0043, 0.0898]], grad_fn=<SigmoidBackward0>), 'y': 174.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(183.4554, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(817.4554, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.4632]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(139.5082, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(288.5082, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.1105]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(181.3320, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(973.3320, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.5671]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(93.1465, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(374.1465, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.1677]], grad_fn=<SigmoidBackward0>), 'y': 280.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.0175, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(349.0175, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0038, 0.1509]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(104.5809, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(866.5809, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.4959]], grad_fn=<SigmoidBackward0>), 'y': 761.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(125.3334, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(983.3334, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.5738]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(23.4369, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(706.4369, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.3892]], grad_fn=<SigmoidBackward0>), 'y': 682.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(92.2445, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(556.7555, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.2894]], grad_fn=<SigmoidBackward0>), 'y': 649.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(120.4174, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(278.5826, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.1040]], grad_fn=<SigmoidBackward0>), 'y': 399.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(140.2126, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(363.7874, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.1607]], grad_fn=<SigmoidBackward0>), 'y': 504.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(201.3998, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(397.6002, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.1833]], grad_fn=<SigmoidBackward0>), 'y': 599.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(215.2282, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(807.7718, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0026, 0.4568]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(147.6071, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(291.3929, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.1125]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(132.7125, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(741.2875, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0038, 0.4124]], grad_fn=<SigmoidBackward0>), 'y': 874.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(139.6797, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(284.3203, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0032, 0.1078]], grad_fn=<SigmoidBackward0>), 'y': 424.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(180.9526, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(583.0474, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.3069]], grad_fn=<SigmoidBackward0>), 'y': 764.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(15.1396, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(247.1396, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.0830]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(55.8902, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(945.1098, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.5483]], grad_fn=<SigmoidBackward0>), 'y': 1001.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(117.7247, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(312.7247, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.1267]], grad_fn=<SigmoidBackward0>), 'y': 194.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(61.1862, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(765.1862, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.4283]], grad_fn=<SigmoidBackward0>), 'y': 703.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(9.0659, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(275.0659, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0040, 0.1016]], grad_fn=<SigmoidBackward0>), 'y': 265.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.0094, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1055.0094, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0032, 0.6216]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(124.1485, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(782.1485, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.4397]], grad_fn=<SigmoidBackward0>), 'y': 657.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.9888, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(326.9888, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0037, 0.1362]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.3433, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(406.3286, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.1891]], grad_fn=<SigmoidBackward0>), 'y': 405.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(28.1384, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1115.1384, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.6616]], grad_fn=<SigmoidBackward0>), 'y': 1086.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(188.1270, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(904.8730, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.5215]], grad_fn=<SigmoidBackward0>), 'y': 1093.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(92.7171, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(231.7171, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.0727]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(115.4741, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(626.5259, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0028, 0.3359]], grad_fn=<SigmoidBackward0>), 'y': 742.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(101.2458, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(273.7542, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.1007]], grad_fn=<SigmoidBackward0>), 'y': 375.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(157.8065, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(342.1935, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.1463]], grad_fn=<SigmoidBackward0>), 'y': 500.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(143.9000, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(756.1000, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.4223]], grad_fn=<SigmoidBackward0>), 'y': 900.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.4791, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(318.5209, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.1306]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(122.0137, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(782.9863, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.4402]], grad_fn=<SigmoidBackward0>), 'y': 905.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(49.4861, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(893.5139, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.5139]], grad_fn=<SigmoidBackward0>), 'y': 943.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.8637, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(436.1363, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.2090]], grad_fn=<SigmoidBackward0>), 'y': 473.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(113.8815, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(393.8815, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.1808]], grad_fn=<SigmoidBackward0>), 'y': 279.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(171.5997, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1144.5997, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.6813]], grad_fn=<SigmoidBackward0>), 'y': 972.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(229.1249, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(621.1249, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.3323]], grad_fn=<SigmoidBackward0>), 'y': 391.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(203.9888, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(376.9888, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.1695]], grad_fn=<SigmoidBackward0>), 'y': 172.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(216.4806, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(465.4806, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.2285]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(203.3414, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(643.3414, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.3471]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(171.7406, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(420.7406, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.1987]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(67.0999, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(306.0999, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.1223]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.7917, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(303.7917, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0038, 0.1207]], grad_fn=<SigmoidBackward0>), 'y': 244.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(8.5178, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(766.5178, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0036, 0.4292]], grad_fn=<SigmoidBackward0>), 'y': 757.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.5871, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(881.4129, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.5058]], grad_fn=<SigmoidBackward0>), 'y': 901.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(249.1887, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(764.8113, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.4281]], grad_fn=<SigmoidBackward0>), 'y': 1014.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(143.3957, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(472.6043, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.2333]], grad_fn=<SigmoidBackward0>), 'y': 616.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(106.5251, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(413.4749, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.1939]], grad_fn=<SigmoidBackward0>), 'y': 520.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.5566, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(839.4434, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.4778]], grad_fn=<SigmoidBackward0>), 'y': 876.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(12.5810, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(562.4190, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0036, 0.2932]], grad_fn=<SigmoidBackward0>), 'y': 575.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(35.8634, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(931.1366, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.5390]], grad_fn=<SigmoidBackward0>), 'y': 967.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(32.2477, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(557.2477, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.2897]], grad_fn=<SigmoidBackward0>), 'y': 524.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(165.3486, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(317.3486, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.1298]], grad_fn=<SigmoidBackward0>), 'y': 151.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(167.9888, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1128.9888, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.6709]], grad_fn=<SigmoidBackward0>), 'y': 960.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(119.0774, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1185.0774, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.7083]], grad_fn=<SigmoidBackward0>), 'y': 1065.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(176.0819, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(320.0819, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.1316]], grad_fn=<SigmoidBackward0>), 'y': 143.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(141.8068, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(837.8068, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0032, 0.4768]], grad_fn=<SigmoidBackward0>), 'y': 695.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(50.6970, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(962.6970, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.5600]], grad_fn=<SigmoidBackward0>), 'y': 911.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(10.5773, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(930.5773, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.5386]], grad_fn=<SigmoidBackward0>), 'y': 919.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(88.5687, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(972.4313, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.5665]], grad_fn=<SigmoidBackward0>), 'y': 1061.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(54.7143, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(231.2857, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0037, 0.0724]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(137.5119, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(802.4881, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.4532]], grad_fn=<SigmoidBackward0>), 'y': 940.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(149.3711, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(277.3711, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0035, 0.1031]], grad_fn=<SigmoidBackward0>), 'y':
127.50000000000001}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(231.3581, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(684.6419, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.3747]], grad_fn=<SigmoidBackward0>), 'y': 916.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(90.4563, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(221.5437, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.0659]], grad_fn=<SigmoidBackward0>), 'y': 312.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(143.0201, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(364.9799, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.1615]], grad_fn=<SigmoidBackward0>), 'y': 508.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(140.7646, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(369.2354, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.1644]], grad_fn=<SigmoidBackward0>), 'y': 510.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(25.9485, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(363.0515, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0036, 0.1602]], grad_fn=<SigmoidBackward0>), 'y': 389.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(108.7618, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(261.7618, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.0927]], grad_fn=<SigmoidBackward0>), 'y': 152.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(4.1018, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(353.1018, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.1536]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(14.5157, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(447.4843, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.2166]], grad_fn=<SigmoidBackward0>), 'y': 462.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(73.8240, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(686.8240, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.3761]], grad_fn=<SigmoidBackward0>), 'y': 612.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(70.4955, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(812.4955, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.4599]], grad_fn=<SigmoidBackward0>), 'y': 741.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.9308, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(805.0692, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0039, 0.4549]], grad_fn=<SigmoidBackward0>), 'y': 864.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(122.9785, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1020.9785, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.5989]], grad_fn=<SigmoidBackward0>), 'y': 897.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(82.8421, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(507.1579, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.2563]], grad_fn=<SigmoidBackward0>), 'y': 590.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(25.9213, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1003.0787, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.5870]], grad_fn=<SigmoidBackward0>), 'y': 1029.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(207.7116, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(913.2884, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.5271]], grad_fn=<SigmoidBackward0>), 'y': 1121.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(61.2433, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(499.7567, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.2514]], grad_fn=<SigmoidBackward0>), 'y': 561.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(64.9711, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(890.9711, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0035, 0.5122]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(144.3783, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(358.3783, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.1571]], grad_fn=<SigmoidBackward0>), 'y': 213.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.0373, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(533.9627, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0031, 0.2742]], grad_fn=<SigmoidBackward0>), 'y': 563.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(186.3120, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1093.3120, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.6471]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(165.0477, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1254.0477, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.7542]], grad_fn=<SigmoidBackward0>), 'y': 1088.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(102.6249, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1095.6249, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0031, 0.6486]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(64.3314, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(303.3314, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.1204]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.0837, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1104.0837, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.6543]], grad_fn=<SigmoidBackward0>), 'y': 1074.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(14.2788, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(522.2788, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.2664]], grad_fn=<SigmoidBackward0>), 'y': 507.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(65.6169, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(215.6169, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.0619]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.8047, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(756.8047, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.4228]], grad_fn=<SigmoidBackward0>), 'y': 737.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(27.4064, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(195.5936, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0033, 0.0486]], grad_fn=<SigmoidBackward0>), 'y': 223.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(234.9482, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(702.0518, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.3863]], grad_fn=<SigmoidBackward0>), 'y': 937.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(273.7822, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(555.2178, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.2884]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(124.3384, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(220.6616, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.0653]], grad_fn=<SigmoidBackward0>), 'y': 345.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(250.9154, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(606.0846, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.3223]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(238.5078, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(375.4922, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.1686]], grad_fn=<SigmoidBackward0>), 'y': 614.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.9926, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(208.0074, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.0569]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(209.0976, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(288.9024, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0036, 0.1108]], grad_fn=<SigmoidBackward0>), 'y': 498.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(96.2781, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(214.7219, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0038, 0.0613]], grad_fn=<SigmoidBackward0>), 'y': 311.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(14.1685, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(213.8315, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.0608]], grad_fn=<SigmoidBackward0>), 'y': 228.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(180.4246, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(261.5754, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.0926]], grad_fn=<SigmoidBackward0>), 'y': 442.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(16.8243, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(261.1757, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.0923]], grad_fn=<SigmoidBackward0>), 'y': 278.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(47.1988, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(358.8012, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.1574]], grad_fn=<SigmoidBackward0>), 'y': 406.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.0544, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1038.0544, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.6103]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(78.0706, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(415.9294, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.1955]], grad_fn=<SigmoidBackward0>), 'y': 494.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(68.8917, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1050.8917, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.6188]], grad_fn=<SigmoidBackward0>), 'y': 981.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(92.9167, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(800.9167, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.4522]], grad_fn=<SigmoidBackward0>), 'y': 707.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(50.2837, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(268.2837, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0040, 0.0970]], grad_fn=<SigmoidBackward0>), 'y': 217.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.8068, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(925.8068, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.5354]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(80.9512, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(953.9512, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.5542]], grad_fn=<SigmoidBackward0>), 'y': 872.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(108.3772, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(950.6228, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.5520]], grad_fn=<SigmoidBackward0>), 'y': 1059.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(35.3306, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(292.6694, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.1133]], grad_fn=<SigmoidBackward0>), 'y': 328.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(69.2991, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(600.7009, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.3187]], grad_fn=<SigmoidBackward0>), 'y': 670.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.5685, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(514.4315, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0037, 0.2612]], grad_fn=<SigmoidBackward0>), 'y': 577.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.6767, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(283.3233, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0038, 0.1071]], grad_fn=<SigmoidBackward0>), 'y': 302.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.5259, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(544.4741, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0031, 0.2812]], grad_fn=<SigmoidBackward0>), 'y': 549.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.7434, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(253.2566, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0037, 0.0870]], grad_fn=<SigmoidBackward0>), 'y': 258.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(101.0453, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(270.0453, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.0982]], grad_fn=<SigmoidBackward0>), 'y': 168.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(35.3767, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(710.3767, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.3918]], grad_fn=<SigmoidBackward0>), 'y': 674.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.1301, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1053.1301, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.6203]], grad_fn=<SigmoidBackward0>), 'y': 1016.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.2397, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(826.1924, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.4690]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.3909, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(703.3909, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.3872]], grad_fn=<SigmoidBackward0>), 'y': 644.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(151.3389, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1173.3389, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.7005]], grad_fn=<SigmoidBackward0>), 'y': 1021.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(66.2816, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(413.7184, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.1940]], grad_fn=<SigmoidBackward0>), 'y': 480.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(152.7979, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(817.2021, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.4630]], grad_fn=<SigmoidBackward0>), 'y': 970.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(84.9127, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(938.0873, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0026, 0.5437]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(213.7543, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(354.2457, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.1544]], grad_fn=<SigmoidBackward0>), 'y': 568.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(155.1167, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(655.8833, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.3555]], grad_fn=<SigmoidBackward0>), 'y': 811.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(50.9951, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(479.0049, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.2376]], grad_fn=<SigmoidBackward0>), 'y': 530.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(33.7177, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(957.7177, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.5567]], grad_fn=<SigmoidBackward0>), 'y': 923.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(37.4983, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(601.5017, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.3192]], grad_fn=<SigmoidBackward0>), 'y': 639.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(33.0608, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(324.0608, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0036, 0.1343]], grad_fn=<SigmoidBackward0>), 'y': 290.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(101.9216, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(735.9216, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.4088]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(1.7996, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(486.2004, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.2423]], grad_fn=<SigmoidBackward0>), 'y': 488.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(84.3284, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(876.3284, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.5024]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(116.2508, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(971.2508, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.5657]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(38.9295, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(953.0705, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0032, 0.5536]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(113.1201, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1053.1201, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0031, 0.6203]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(45.6628, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(653.6628, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.3540]], grad_fn=<SigmoidBackward0>), 'y': 607.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(79.7623, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(939.7623, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.5447]], grad_fn=<SigmoidBackward0>), 'y': 859.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(14.9265, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(918.0735, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.5303]], grad_fn=<SigmoidBackward0>), 'y': 933.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(107.1024, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(721.8976, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.3995]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(68.7231, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(754.2769, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0035, 0.4211]], grad_fn=<SigmoidBackward0>), 'y': 823.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(128.5639, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(489.4361, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.2445]], grad_fn=<SigmoidBackward0>), 'y': 618.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.6933, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(477.3067, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.2364]], grad_fn=<SigmoidBackward0>), 'y': 540.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(7.6298, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(846.6298, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.4827]], grad_fn=<SigmoidBackward0>), 'y': 838.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(54.5928, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(303.5928, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.1206]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(65.2868, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(473.7132, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.2340]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(85.0370, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(234.0370, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.0742]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(5.6199, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(564.6199, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.2946]], grad_fn=<SigmoidBackward0>), 'y': 558.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(160.6766, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1183.6766, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0027, 0.7074]], grad_fn=<SigmoidBackward0>), 'y': 1022.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(7.6544, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(958.3456, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0038, 0.5571]], grad_fn=<SigmoidBackward0>), 'y': 966.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(30.2895, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(361.7105, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.1594]], grad_fn=<SigmoidBackward0>), 'y': 392.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.4306, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(732.5720, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0031, 0.4066]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(26.3879, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(512.6121, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.2600]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(148.1416, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1088.1416, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0031, 0.6437]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(108.0078, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(729.0078, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.4042]], grad_fn=<SigmoidBackward0>), 'y': 620.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(199.3539, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(795.3539, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.4485]], grad_fn=<SigmoidBackward0>), 'y': 595.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(74.8306, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(808.8306, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0031, 0.4575]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.3725, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(827.3725, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.4698]], grad_fn=<SigmoidBackward0>), 'y': 790.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.4177, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(822.5823, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.4666]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(92.6515, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(428.3485, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.2038]], grad_fn=<SigmoidBackward0>), 'y': 521.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(158.9812, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(898.0188, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.5169]], grad_fn=<SigmoidBackward0>), 'y': 1057.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(95.2546, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(234.2546, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.0744]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(46.5161, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(310.4839, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.1252]], grad_fn=<SigmoidBackward0>), 'y': 357.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(65.8204, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(785.1796, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0037, 0.4417]], grad_fn=<SigmoidBackward0>), 'y': 851.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(106.3910, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(624.6090, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.3346]], grad_fn=<SigmoidBackward0>), 'y': 731.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(84.4056, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1011.4056, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0030, 0.5925]], grad_fn=<SigmoidBackward0>), 'y': 926.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(112.0562, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(958.9438, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.5575]], grad_fn=<SigmoidBackward0>), 'y': 1071.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(90.0757, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1070.0757, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0033, 0.6316]], grad_fn=<SigmoidBackward0>), 'y': 979.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(52.2639, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1051.7361, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.6194]], grad_fn=<SigmoidBackward0>), 'y': 1104.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(86.6949, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1151.6949, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.6860]], grad_fn=<SigmoidBackward0>), 'y': 1064.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(232.4407, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(827.4407, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.4699]], grad_fn=<SigmoidBackward0>), 'y': 594.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(186.9517, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(871.9517, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.4995]], grad_fn=<SigmoidBackward0>), 'y': 684.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(34.0085, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(527.0085, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.2695]], grad_fn=<SigmoidBackward0>), 'y': 492.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(55.1554, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(287.1554, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.1096]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(12.4589, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1012.5411, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.5933]], grad_fn=<SigmoidBackward0>), 'y': 1025.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(173.7157, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(743.2843, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0033, 0.4137]], grad_fn=<SigmoidBackward0>), 'y': 917.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(21.1787, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(792.8213, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.4468]], grad_fn=<SigmoidBackward0>), 'y': 814.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.0073, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(334.3796, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.1411]], grad_fn=<SigmoidBackward0>), 'y': 334.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(28.4562, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(312.4562, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0038, 0.1265]], grad_fn=<SigmoidBackward0>), 'y': 283.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(88.1883, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(965.8117, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0040, 0.5620]], grad_fn=<SigmoidBackward0>), 'y': 1054.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(90.9266, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(240.9266, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.0788]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(67.2402, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(740.2402, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.4117]], grad_fn=<SigmoidBackward0>), 'y': 672.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(70.6787, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1044.3213, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.6144]], grad_fn=<SigmoidBackward0>), 'y': 1115.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(98.8766, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(309.8766, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0039, 0.1248]], grad_fn=<SigmoidBackward0>), 'y': 210.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(117.4696, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(887.4696, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0036, 0.5099]], grad_fn=<SigmoidBackward0>), 'y': 769.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(77.2862, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(259.2862, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0041, 0.0910]], grad_fn=<SigmoidBackward0>), 'y': 181.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(82.5847, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(920.5847, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.5320]], grad_fn=<SigmoidBackward0>), 'y': 837.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.3564, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(366.6436, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.1627]], grad_fn=<SigmoidBackward0>), 'y': 371.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.8518, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(428.1482, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.2037]], grad_fn=<SigmoidBackward0>), 'y': 433.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(40.8396, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1048.1604, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.6170]], grad_fn=<SigmoidBackward0>), 'y': 1089.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(9.0426, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(495.0426, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.2482]], grad_fn=<SigmoidBackward0>), 'y': 485.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(35.8559, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(429.1441, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0030, 0.2043]], grad_fn=<SigmoidBackward0>), 'y': 465.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(20.9785, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1040.9785, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.6122]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(54.0235, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(376.9765, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.1695]], grad_fn=<SigmoidBackward0>), 'y': 431.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(50.3399, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(225.3399, grad_fn=<AddBackward0>), 'output':
tensor([[0.0028, 0.0042, 0.0684]], grad_fn=<SigmoidBackward0>), 'y': 174.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(17.7516, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(651.7516, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.3527]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(70.1305, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(219.1305, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.0643]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(96.1317, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(694.8683, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.3815]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.3574, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(260.6426, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.0920]], grad_fn=<SigmoidBackward0>), 'y': 280.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(27.3802, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(258.6198, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0037, 0.0906]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(59.8755, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(701.1245, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.3856]], grad_fn=<SigmoidBackward0>), 'y': 761.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(65.3315, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(923.3315, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.5338]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(38.8409, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(721.8409, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.3994]], grad_fn=<SigmoidBackward0>), 'y': 682.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.6174, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(650.6174, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.3520]], grad_fn=<SigmoidBackward0>), 'y': 649.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.7869, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(340.2131, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.1450]], grad_fn=<SigmoidBackward0>), 'y': 399.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(38.6693, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(465.3307, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.2284]], grad_fn=<SigmoidBackward0>), 'y': 504.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(70.9719, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(528.0281, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.2702]], grad_fn=<SigmoidBackward0>), 'y': 599.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(16.0334, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1040.0334, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0026, 0.6116]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(48.1161, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(390.8839, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.1788]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(34.6812, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(909.6812, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0038, 0.5247]], grad_fn=<SigmoidBackward0>), 'y': 874.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(88.6182, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(335.3818, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.1418]], grad_fn=<SigmoidBackward0>), 'y': 424.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(141.7930, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(622.2070, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.3330]], grad_fn=<SigmoidBackward0>), 'y': 764.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(10.2313, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(242.2313, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.0797]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(110.7017, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(890.2983, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.5118]], grad_fn=<SigmoidBackward0>), 'y': 1001.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(79.2483, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(274.2483, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.1010]], grad_fn=<SigmoidBackward0>), 'y': 194.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(77.5352, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(625.4648, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.3352]], grad_fn=<SigmoidBackward0>), 'y': 703.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(27.8844, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(237.1156, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0040, 0.0763]], grad_fn=<SigmoidBackward0>), 'y': 265.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(20.1294, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(971.8706, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0032, 0.5661]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(110.6925, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(768.6925, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.4307]], grad_fn=<SigmoidBackward0>), 'y': 657.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(77.5471, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(364.5471, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0038, 0.1612]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(104.4229, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(510.4229, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.2585]], grad_fn=<SigmoidBackward0>), 'y': 405.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(180.1355, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1267.1355, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.7630]], grad_fn=<SigmoidBackward0>), 'y': 1086.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(37.0081, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1131.0081, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.6722]], grad_fn=<SigmoidBackward0>), 'y': 1093.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(169.4504, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(308.4504, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.1238]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(103.7993, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(846.7993, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0028, 0.4828]], grad_fn=<SigmoidBackward0>), 'y': 742.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(24.0177, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(350.9823, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.1522]], grad_fn=<SigmoidBackward0>), 'y': 375.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(90.2115, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(409.7885, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.1914]], grad_fn=<SigmoidBackward0>), 'y': 500.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(65.1261, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(834.8739, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.4748]], grad_fn=<SigmoidBackward0>), 'y': 900.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.6956, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(343.3044, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.1471]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(117.3758, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(787.6242, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.4433]], grad_fn=<SigmoidBackward0>), 'y': 905.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(71.0914, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(871.9086, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.4995]], grad_fn=<SigmoidBackward0>), 'y': 943.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(59.1741, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(413.8259, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0031, 0.1941]], grad_fn=<SigmoidBackward0>), 'y': 473.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(73.6041, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(353.6041, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.1540]], grad_fn=<SigmoidBackward0>), 'y': 279.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(79.4098, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1052.4098, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.6198]], grad_fn=<SigmoidBackward0>), 'y': 972.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(145.1960, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(537.1960, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.2763]], grad_fn=<SigmoidBackward0>), 'y': 391.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(144.0275, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(317.0275, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.1295]], grad_fn=<SigmoidBackward0>), 'y': 172.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(128.9234, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(377.9234, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.1701]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(95.6230, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(535.6230, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.2753]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(89.2093, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(338.2093, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.1437]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.5035, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(252.5035, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.0865]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(8.3854, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(253.3854, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0038, 0.0871]], grad_fn=<SigmoidBackward0>), 'y': 244.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(119.1083, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(637.8917, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0036, 0.3435]], grad_fn=<SigmoidBackward0>), 'y': 757.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(93.6315, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(807.3685, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.4564]], grad_fn=<SigmoidBackward0>), 'y': 901.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(278.3055, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(735.6945, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0035, 0.4087]], grad_fn=<SigmoidBackward0>), 'y': 1014.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(123.8122, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(492.1878, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.2463]], grad_fn=<SigmoidBackward0>), 'y': 616.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.4878, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(457.5122, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.2232]], grad_fn=<SigmoidBackward0>), 'y': 520.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(43.9562, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(920.9562, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.5322]], grad_fn=<SigmoidBackward0>), 'y': 876.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(70.6945, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(646.6945, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.3493]], grad_fn=<SigmoidBackward0>), 'y': 575.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.4446, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(947.5554, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.5499]], grad_fn=<SigmoidBackward0>), 'y': 967.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.3807, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(538.3807, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.2771]], grad_fn=<SigmoidBackward0>), 'y': 524.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(127.6172, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(279.6172, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.1046]], grad_fn=<SigmoidBackward0>), 'y': 151.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(43.4680, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1004.4680, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.5878]], grad_fn=<SigmoidBackward0>), 'y': 960.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(41.8018, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1023.1982, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.6003]], grad_fn=<SigmoidBackward0>), 'y': 1065.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(115.9255, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(259.9255, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.0915]], grad_fn=<SigmoidBackward0>), 'y': 143.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.8896, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(681.1104, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0032, 0.3723]], grad_fn=<SigmoidBackward0>), 'y': 695.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(27.4597, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(883.5403, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.5072]], grad_fn=<SigmoidBackward0>), 'y': 911.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(38.0936, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(958.0936, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.5570]], grad_fn=<SigmoidBackward0>), 'y': 919.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(26.7275, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1088.7275, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.6440]], grad_fn=<SigmoidBackward0>), 'y': 1061.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.0009, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(286.4577, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0037, 0.1092]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(54.1935, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(995.1935, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.5817]], grad_fn=<SigmoidBackward0>), 'y': 940.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(208.0558, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(336.0558, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0035, 0.1422]], grad_fn=<SigmoidBackward0>), 'y':
127.50000000000001}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(100.0125, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(815.9875, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.4622]], grad_fn=<SigmoidBackward0>), 'y': 916.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.6446, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(255.3554, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.0884]], grad_fn=<SigmoidBackward0>), 'y': 312.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(84.6464, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(423.3536, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.2005]], grad_fn=<SigmoidBackward0>), 'y': 508.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(93.6487, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(416.3513, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.1958]], grad_fn=<SigmoidBackward0>), 'y': 510.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.1062, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(403.1062, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0036, 0.1870]], grad_fn=<SigmoidBackward0>), 'y': 389.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(113.1254, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(266.1254, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.0956]], grad_fn=<SigmoidBackward0>), 'y': 152.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(5.6517, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(354.6517, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.1547]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.4200, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(422.5800, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.2000]], grad_fn=<SigmoidBackward0>), 'y': 462.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(2.8781, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(609.1219, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.3243]], grad_fn=<SigmoidBackward0>), 'y': 612.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.3781, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(742.3696, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.4132]], grad_fn=<SigmoidBackward0>), 'y': 741.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(99.1707, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(764.8293, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0039, 0.4281]], grad_fn=<SigmoidBackward0>), 'y': 864.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(97.9849, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(995.9849, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.5822]], grad_fn=<SigmoidBackward0>), 'y': 897.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(75.1064, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(514.8936, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.2615]], grad_fn=<SigmoidBackward0>), 'y': 590.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.2798, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1010.7202, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.5921]], grad_fn=<SigmoidBackward0>), 'y': 1029.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(170.8937, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(950.1063, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.5516]], grad_fn=<SigmoidBackward0>), 'y': 1121.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(11.2097, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(549.7903, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.2848]], grad_fn=<SigmoidBackward0>), 'y': 561.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(120.6834, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(946.6834, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0035, 0.5493]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(183.5468, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(397.5468, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.1832]], grad_fn=<SigmoidBackward0>), 'y': 213.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(57.0394, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(621.0394, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0031, 0.3323]], grad_fn=<SigmoidBackward0>), 'y': 563.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(218.1641, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1125.1641, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.6683]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(168.9835, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1257.9835, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.7569]], grad_fn=<SigmoidBackward0>), 'y': 1088.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(80.6614, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1073.6614, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0031, 0.6340]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(46.0247, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(285.0247, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.1082]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(40.4624, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1033.5376, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.6072]], grad_fn=<SigmoidBackward0>), 'y': 1074.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(10.0907, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(496.9093, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.2495]], grad_fn=<SigmoidBackward0>), 'y': 507.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(71.6274, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(221.6274, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.0659]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(92.7449, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(830.7449, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.4721]], grad_fn=<SigmoidBackward0>), 'y': 737.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(2.8162, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(226.8162, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0033, 0.0694]], grad_fn=<SigmoidBackward0>), 'y': 223.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(74.4785, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(862.5215, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.4933]], grad_fn=<SigmoidBackward0>), 'y': 937.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(98.9417, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(730.0583, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.4049]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(44.2156, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(300.7844, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.1187]], grad_fn=<SigmoidBackward0>), 'y': 345.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(1.9305, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(855.0695, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.4883]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(12.3088, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(601.6912, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.3194]], grad_fn=<SigmoidBackward0>), 'y': 614.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(68.9488, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(317.9488, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.1302]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.2099, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(503.2099, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0036, 0.2537]], grad_fn=<SigmoidBackward0>), 'y': 498.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(27.5311, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(339.5311, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0038, 0.1446]], grad_fn=<SigmoidBackward0>), 'y': 311.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(90.8745, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(319.8745, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.1315]], grad_fn=<SigmoidBackward0>), 'y': 228.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(45.3725, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(396.6275, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.1827]], grad_fn=<SigmoidBackward0>), 'y': 442.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(85.0641, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(364.0641, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.1609]], grad_fn=<SigmoidBackward0>), 'y': 278.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(73.9533, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(480.9533, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.2389]], grad_fn=<SigmoidBackward0>), 'y': 406.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(95.9453, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1115.9453, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.6622]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(57.8908, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(436.1092, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.2089]], grad_fn=<SigmoidBackward0>), 'y': 494.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(28.5443, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1010.5443, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.5919]], grad_fn=<SigmoidBackward0>), 'y': 981.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(6.2926, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(700.7074, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.3854]], grad_fn=<SigmoidBackward0>), 'y': 707.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.0489, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(237.0489, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0039, 0.0762]], grad_fn=<SigmoidBackward0>), 'y': 217.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(81.5170, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(824.4830, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.4679]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.6287, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(904.6287, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.5213]], grad_fn=<SigmoidBackward0>), 'y': 872.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(103.5010, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(955.4990, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.5552]], grad_fn=<SigmoidBackward0>), 'y': 1059.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(11.8428, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(316.1572, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.1290]], grad_fn=<SigmoidBackward0>), 'y': 328.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(8.3650, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(679.3650, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.3712]], grad_fn=<SigmoidBackward0>), 'y': 670.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.7606, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(578.7606, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0036, 0.3041]], grad_fn=<SigmoidBackward0>), 'y': 577.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(9.7707, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(292.2293, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.1130]], grad_fn=<SigmoidBackward0>), 'y': 302.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.3066, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(530.6934, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0030, 0.2720]], grad_fn=<SigmoidBackward0>), 'y': 549.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(27.5157, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(230.4843, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0036, 0.0719]], grad_fn=<SigmoidBackward0>), 'y': 258.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(65.1018, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(234.1018, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0037, 0.0743]], grad_fn=<SigmoidBackward0>), 'y': 168.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(99.1406, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(574.8594, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.3015]], grad_fn=<SigmoidBackward0>), 'y': 674.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(93.0513, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(922.9487, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.5335]], grad_fn=<SigmoidBackward0>), 'y': 1016.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.3197, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(768.6803, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0034, 0.4307]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(95.8082, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(740.8082, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.4121]], grad_fn=<SigmoidBackward0>), 'y': 644.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(256.8252, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1278.8252, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.7708]], grad_fn=<SigmoidBackward0>), 'y': 1021.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(108.5344, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(589.5344, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.3113]], grad_fn=<SigmoidBackward0>), 'y': 480.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(103.3958, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1074.3958, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.6345]], grad_fn=<SigmoidBackward0>), 'y': 970.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(157.3612, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1181.3612, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0025, 0.7058]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(91.5297, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(476.4703, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.2359]], grad_fn=<SigmoidBackward0>), 'y': 568.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(14.9775, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(796.0225, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0030, 0.4489]], grad_fn=<SigmoidBackward0>), 'y': 811.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.6260, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(562.6260, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.2933]], grad_fn=<SigmoidBackward0>), 'y': 530.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(41.1387, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(965.1387, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.5617]], grad_fn=<SigmoidBackward0>), 'y': 923.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(92.2119, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(546.7881, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.2828]], grad_fn=<SigmoidBackward0>), 'y': 639.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(22.2643, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(267.7357, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.0967]], grad_fn=<SigmoidBackward0>), 'y': 290.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(55.2437, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(577.7563, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.3034]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(98.7917, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(389.2083, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.1777]], grad_fn=<SigmoidBackward0>), 'y': 488.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(72.4318, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(718.5682, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.3973]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(14.3248, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(869.3248, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.4978]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(77.0125, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(914.9875, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0031, 0.5282]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(113.2649, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1053.2649, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0030, 0.6204]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(94.4584, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(702.4584, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0034, 0.3865]], grad_fn=<SigmoidBackward0>), 'y': 607.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(159.7092, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1019.7092, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.5980]], grad_fn=<SigmoidBackward0>), 'y': 859.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(106.8091, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1040.8091, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.6121]], grad_fn=<SigmoidBackward0>), 'y': 933.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(5.0959, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(823.9041, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.4675]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.2532, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(843.2532, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.4804]], grad_fn=<SigmoidBackward0>), 'y': 823.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(109.5705, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(508.4295, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.2572]], grad_fn=<SigmoidBackward0>), 'y': 618.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(86.5777, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(453.4223, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.2205]], grad_fn=<SigmoidBackward0>), 'y': 540.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(110.7845, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(727.2155, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.4031]], grad_fn=<SigmoidBackward0>), 'y': 838.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.2346, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(262.2346, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.0930]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(119.7420, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(419.2580, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.1977]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(63.0608, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(212.0608, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.0596]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(67.9160, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(490.0840, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.2450]], grad_fn=<SigmoidBackward0>), 'y': 558.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(99.4463, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1122.4463, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0026, 0.6666]], grad_fn=<SigmoidBackward0>), 'y': 1022.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(22.2073, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(943.7927, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.5474]], grad_fn=<SigmoidBackward0>), 'y': 966.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(15.2015, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(376.7985, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.1694]], grad_fn=<SigmoidBackward0>), 'y': 392.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(66.0521, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(800.0521, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.4516]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(15.4407, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(555.4407, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.2885]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(110.1956, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1050.1956, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0030, 0.6184]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(37.6871, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(658.6871, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.3574]], grad_fn=<SigmoidBackward0>), 'y': 620.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(68.3370, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(664.3370, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.3611]], grad_fn=<SigmoidBackward0>), 'y': 595.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(89.7429, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(643.2571, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.3471]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(120.8422, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(669.1578, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.3643]], grad_fn=<SigmoidBackward0>), 'y': 790.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(138.8842, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(715.1158, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.3950]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(113.3362, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(407.6638, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.1900]], grad_fn=<SigmoidBackward0>), 'y': 521.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(159.8431, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(897.1569, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.5163]], grad_fn=<SigmoidBackward0>), 'y': 1057.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(107.1767, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(246.1767, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0036, 0.0823]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(2.1290, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(354.8710, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.1548]], grad_fn=<SigmoidBackward0>), 'y': 357.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(60.0470, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(912.0470, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.5263]], grad_fn=<SigmoidBackward0>), 'y': 851.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.7115, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(736.7115, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.4094]], grad_fn=<SigmoidBackward0>), 'y': 731.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(110.1227, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1037.1227, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.6097]], grad_fn=<SigmoidBackward0>), 'y': 926.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(132.0812, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(938.9188, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.5442]], grad_fn=<SigmoidBackward0>), 'y': 1071.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.2833, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(998.2833, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.5838]], grad_fn=<SigmoidBackward0>), 'y': 979.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(172.2440, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(931.7560, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.5394]], grad_fn=<SigmoidBackward0>), 'y': 1104.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(66.5788, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(997.4212, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.5832]], grad_fn=<SigmoidBackward0>), 'y': 1064.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(74.1406, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(669.1406, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.3643]], grad_fn=<SigmoidBackward0>), 'y': 594.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(30.7751, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(715.7751, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.3954]], grad_fn=<SigmoidBackward0>), 'y': 684.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(64.5760, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(427.4240, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.2032]], grad_fn=<SigmoidBackward0>), 'y': 492.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(21.6779, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(253.6779, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.0873]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(73.4726, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(951.5274, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.5526]], grad_fn=<SigmoidBackward0>), 'y': 1025.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(173.2901, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(743.7099, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0032, 0.4140]], grad_fn=<SigmoidBackward0>), 'y': 917.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(15.7385, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(830.7385, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.4721]], grad_fn=<SigmoidBackward0>), 'y': 814.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(5.8012, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(340.8012, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.1454]], grad_fn=<SigmoidBackward0>), 'y': 334.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(15.4486, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(299.4486, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0037, 0.1178]], grad_fn=<SigmoidBackward0>), 'y': 283.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(144.7128, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(909.2872, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.5244]], grad_fn=<SigmoidBackward0>), 'y': 1054.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(69.9822, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(219.9822, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.0649]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(35.8973, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(636.1027, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.3423]], grad_fn=<SigmoidBackward0>), 'y': 672.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(144.4261, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(970.5739, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.5653]], grad_fn=<SigmoidBackward0>), 'y': 1115.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(76.2709, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(287.2709, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.1097]], grad_fn=<SigmoidBackward0>), 'y': 210.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(89.1825, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(859.1825, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0035, 0.4910]], grad_fn=<SigmoidBackward0>), 'y': 769.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(77.5480, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(259.5480, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0039, 0.0912]], grad_fn=<SigmoidBackward0>), 'y': 181.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(99.7902, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(937.7902, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.5435]], grad_fn=<SigmoidBackward0>), 'y': 837.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.6317, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(391.6317, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.1793]], grad_fn=<SigmoidBackward0>), 'y': 371.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.2570, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(453.2570, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.2204]], grad_fn=<SigmoidBackward0>), 'y': 433.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(57.6292, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1031.3708, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.6058]], grad_fn=<SigmoidBackward0>), 'y': 1089.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(32.5417, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(452.4583, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.2199]], grad_fn=<SigmoidBackward0>), 'y': 485.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(73.6758, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(391.3242, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.1791]], grad_fn=<SigmoidBackward0>), 'y': 465.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.4212, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(960.5788, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.5586]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.7242, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(374.2758, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.1678]], grad_fn=<SigmoidBackward0>), 'y': 431.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.2736, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(233.2736, grad_fn=<AddBackward0>), 'output':
tensor([[0.0026, 0.0040, 0.0737]], grad_fn=<SigmoidBackward0>), 'y': 174.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(89.0740, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(723.0740, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.4003]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(99.0201, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(248.0201, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.0835]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(42.1081, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(834.1081, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.4743]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.9576, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(300.9576, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.1189]], grad_fn=<SigmoidBackward0>), 'y': 280.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.9850, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(282.0150, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0036, 0.1062]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.6463, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(729.3537, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.4045]], grad_fn=<SigmoidBackward0>), 'y': 761.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(59.7885, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(917.7885, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.5301]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(5.7574, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(688.7574, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.3774]], grad_fn=<SigmoidBackward0>), 'y': 682.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.6935, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(592.3065, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.3131]], grad_fn=<SigmoidBackward0>), 'y': 649.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(73.7147, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(325.2853, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.1351]], grad_fn=<SigmoidBackward0>), 'y': 399.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(42.1647, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(461.8353, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.2261]], grad_fn=<SigmoidBackward0>), 'y': 504.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(64.3164, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(534.6836, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.2747]], grad_fn=<SigmoidBackward0>), 'y': 599.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.7161, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1055.7161, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0025, 0.6221]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(16.5297, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(422.4703, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.1999]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(95.0449, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(970.0449, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0036, 0.5649]], grad_fn=<SigmoidBackward0>), 'y': 874.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(47.2403, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(376.7597, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0031, 0.1694]], grad_fn=<SigmoidBackward0>), 'y': 424.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(57.3716, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(706.6284, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.3893]], grad_fn=<SigmoidBackward0>), 'y': 764.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(41.1827, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(273.1827, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.1003]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.3842, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1005.3842, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.5885]], grad_fn=<SigmoidBackward0>), 'y': 1001.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(107.1846, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(302.1846, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.1197]], grad_fn=<SigmoidBackward0>), 'y': 194.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.2739, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(666.7261, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.3627]], grad_fn=<SigmoidBackward0>), 'y': 703.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(28.1823, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(236.8177, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0038, 0.0761]], grad_fn=<SigmoidBackward0>), 'y': 265.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(52.0528, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(939.9472, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0030, 0.5449]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(51.2672, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(709.2672, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.3911]], grad_fn=<SigmoidBackward0>), 'y': 657.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.8094, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(323.8094, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0036, 0.1341]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(32.8334, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(438.8334, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.2108]], grad_fn=<SigmoidBackward0>), 'y': 405.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(92.7589, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1179.7589, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.7047]], grad_fn=<SigmoidBackward0>), 'y': 1086.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(81.2632, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1011.7368, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.5927]], grad_fn=<SigmoidBackward0>), 'y': 1093.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(131.2999, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(270.2999, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.0984]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(33.8564, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(776.8564, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.4362]], grad_fn=<SigmoidBackward0>), 'y': 742.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(43.2083, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(331.7917, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.1394]], grad_fn=<SigmoidBackward0>), 'y': 375.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(92.4796, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(407.5204, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.1899]], grad_fn=<SigmoidBackward0>), 'y': 500.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(42.1820, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(857.8180, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.4901]], grad_fn=<SigmoidBackward0>), 'y': 900.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.3625, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(362.3625, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.1598]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(86.4189, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(818.5811, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.4639]], grad_fn=<SigmoidBackward0>), 'y': 905.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.7783, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(886.2217, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0035, 0.5090]], grad_fn=<SigmoidBackward0>), 'y': 943.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(45.6108, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(427.3892, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.2032]], grad_fn=<SigmoidBackward0>), 'y': 473.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(69.3757, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(349.3757, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0031, 0.1512]], grad_fn=<SigmoidBackward0>), 'y': 279.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(70.7090, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1043.7090, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.6140]], grad_fn=<SigmoidBackward0>), 'y': 972.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(136.3624, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(528.3624, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.2705]], grad_fn=<SigmoidBackward0>), 'y': 391.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(139.9793, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(312.9793, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0037, 0.1268]], grad_fn=<SigmoidBackward0>), 'y': 172.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(114.7989, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(363.7989, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.1607]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(87.4736, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(527.4736, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.2699]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(74.9108, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(323.9108, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.1342]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.2299, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(243.2299, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.0804]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.3888, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(243.6181, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0036, 0.0806]], grad_fn=<SigmoidBackward0>), 'y': 244.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(120.5320, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(636.4680, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.3425]], grad_fn=<SigmoidBackward0>), 'y': 757.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(73.4961, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(827.5039, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.4699]], grad_fn=<SigmoidBackward0>), 'y': 901.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(255.7443, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(758.2557, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.4237]], grad_fn=<SigmoidBackward0>), 'y': 1014.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(89.3500, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(526.6500, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.2693]], grad_fn=<SigmoidBackward0>), 'y': 616.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(22.3761, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(497.6239, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.2500]], grad_fn=<SigmoidBackward0>), 'y': 520.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(100.6390, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(977.6390, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.5700]], grad_fn=<SigmoidBackward0>), 'y': 876.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(137.1457, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(713.1457, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0035, 0.3937]], grad_fn=<SigmoidBackward0>), 'y': 575.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(48.6069, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1016.6069, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.5960]], grad_fn=<SigmoidBackward0>), 'y': 967.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(44.9034, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(569.9034, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.2982]], grad_fn=<SigmoidBackward0>), 'y': 524.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(122.1863, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(274.1863, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.1010]], grad_fn=<SigmoidBackward0>), 'y': 151.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(10.9125, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(949.0875, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.5509]], grad_fn=<SigmoidBackward0>), 'y': 960.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.3866, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1002.6134, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.5866]], grad_fn=<SigmoidBackward0>), 'y': 1065.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(111.8436, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(255.8436, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.0888]], grad_fn=<SigmoidBackward0>), 'y': 143.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.0056, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(695.6058, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.3820]], grad_fn=<SigmoidBackward0>), 'y': 695.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.1592, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(881.8408, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.5061]], grad_fn=<SigmoidBackward0>), 'y': 911.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.2997, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(939.2997, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.5444]], grad_fn=<SigmoidBackward0>), 'y': 919.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(1.0576, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1063.0576, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.6269]], grad_fn=<SigmoidBackward0>), 'y': 1061.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(15.7124, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(270.2876, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0035, 0.0984]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.3148, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(941.2935, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.5458]], grad_fn=<SigmoidBackward0>), 'y': 940.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(183.2589, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(311.2589, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.1257]], grad_fn=<SigmoidBackward0>), 'y':
127.50000000000001}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(126.2400, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(789.7600, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.4447]], grad_fn=<SigmoidBackward0>), 'y': 916.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(66.2554, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(245.7446, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0036, 0.0820]], grad_fn=<SigmoidBackward0>), 'y': 312.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(91.8131, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(416.1869, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.1957]], grad_fn=<SigmoidBackward0>), 'y': 508.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(102.0423, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(407.9577, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.1902]], grad_fn=<SigmoidBackward0>), 'y': 510.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(0.0997, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(389.0534, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.1776]], grad_fn=<SigmoidBackward0>), 'y': 389.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(113.3774, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(266.3774, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.0958]], grad_fn=<SigmoidBackward0>), 'y': 152.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.1066, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(367.1066, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0032, 0.1630]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.8875, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(457.1125, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.2230]], grad_fn=<SigmoidBackward0>), 'y': 462.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(61.1337, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(674.1337, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.3677]], grad_fn=<SigmoidBackward0>), 'y': 612.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.9765, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(771.9765, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.4329]], grad_fn=<SigmoidBackward0>), 'y': 741.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(87.9521, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(776.0479, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0038, 0.4356]], grad_fn=<SigmoidBackward0>), 'y': 864.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(81.7188, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(979.7188, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.5714]], grad_fn=<SigmoidBackward0>), 'y': 897.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(109.7127, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(480.2873, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.2384]], grad_fn=<SigmoidBackward0>), 'y': 590.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(95.3244, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(933.6756, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.5407]], grad_fn=<SigmoidBackward0>), 'y': 1029.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(259.9789, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(861.0211, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.4922]], grad_fn=<SigmoidBackward0>), 'y': 1121.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(92.7480, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(468.2520, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.2304]], grad_fn=<SigmoidBackward0>), 'y': 561.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(8.8047, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(816.1953, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.4624]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(126.4836, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(340.4836, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.1452]], grad_fn=<SigmoidBackward0>), 'y': 213.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.8183, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(568.8183, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.2975]], grad_fn=<SigmoidBackward0>), 'y': 563.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(194.3582, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1101.3582, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.6525]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(171.9353, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1260.9353, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.7589]], grad_fn=<SigmoidBackward0>), 'y': 1088.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(96.4883, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1089.4883, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0030, 0.6446]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(59.9586, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(298.9586, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.1175]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(32.4783, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1107.4783, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.6565]], grad_fn=<SigmoidBackward0>), 'y': 1074.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(24.3809, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(532.3809, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.2732]], grad_fn=<SigmoidBackward0>), 'y': 507.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(63.8266, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(213.8266, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.0608]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(10.6279, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(726.3721, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.4025]], grad_fn=<SigmoidBackward0>), 'y': 737.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.8961, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(203.1039, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0032, 0.0536]], grad_fn=<SigmoidBackward0>), 'y': 223.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(170.6619, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(766.3381, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.4291]], grad_fn=<SigmoidBackward0>), 'y': 937.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(167.0610, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(661.9390, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.3595]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(72.0011, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(272.9989, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0035, 0.1002]], grad_fn=<SigmoidBackward0>), 'y': 345.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(65.9127, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(791.0873, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.4456]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(61.5633, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(552.4367, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0031, 0.2865]], grad_fn=<SigmoidBackward0>), 'y': 614.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(41.3337, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(290.3337, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.1118]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.0305, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(461.9695, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.2262]], grad_fn=<SigmoidBackward0>), 'y': 498.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(21.0315, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(333.0315, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0037, 0.1402]], grad_fn=<SigmoidBackward0>), 'y': 311.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(98.2827, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(327.2827, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.1364]], grad_fn=<SigmoidBackward0>), 'y': 228.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.3128, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(438.6872, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.2107]], grad_fn=<SigmoidBackward0>), 'y': 442.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(131.3051, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(410.3051, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.1918]], grad_fn=<SigmoidBackward0>), 'y': 278.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(160.6071, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(567.6071, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.2966]], grad_fn=<SigmoidBackward0>), 'y': 406.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(212.7698, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1232.7698, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.7401]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(67.7491, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(562.7491, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.2934]], grad_fn=<SigmoidBackward0>), 'y': 494.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(153.3157, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1135.3157, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.6751]], grad_fn=<SigmoidBackward0>), 'y': 981.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(121.1061, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(829.1061, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.4710]], grad_fn=<SigmoidBackward0>), 'y': 707.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.3326, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(254.3326, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.0878]], grad_fn=<SigmoidBackward0>), 'y': 217.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(75.5154, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(830.4846, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.4719]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(15.8954, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(856.1046, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.4890]], grad_fn=<SigmoidBackward0>), 'y': 872.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(142.6240, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(916.3760, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.5292]], grad_fn=<SigmoidBackward0>), 'y': 1059.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(30.8767, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(297.1233, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.1163]], grad_fn=<SigmoidBackward0>), 'y': 328.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(33.0999, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(636.9001, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.3428]], grad_fn=<SigmoidBackward0>), 'y': 670.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(12.1412, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(590.1412, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0035, 0.3117]], grad_fn=<SigmoidBackward0>), 'y': 577.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(12.5403, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(315.5403, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0035, 0.1286]], grad_fn=<SigmoidBackward0>), 'y': 302.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(50.4347, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(600.4347, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.3185]], grad_fn=<SigmoidBackward0>), 'y': 549.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(15.5491, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(242.4509, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.0799]], grad_fn=<SigmoidBackward0>), 'y': 258.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(71.7550, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(240.7550, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.0787]], grad_fn=<SigmoidBackward0>), 'y': 168.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(98.3785, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(575.6215, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.3020]], grad_fn=<SigmoidBackward0>), 'y': 674.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(103.3370, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(912.6630, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.5267]], grad_fn=<SigmoidBackward0>), 'y': 1016.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(79.5438, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(745.4562, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0032, 0.4152]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(44.5743, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(689.5743, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.3780]], grad_fn=<SigmoidBackward0>), 'y': 644.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(201.3002, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1223.3002, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.7338]], grad_fn=<SigmoidBackward0>), 'y': 1021.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(35.8387, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(516.8387, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.2628]], grad_fn=<SigmoidBackward0>), 'y': 480.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(5.5403, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(976.5403, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.5693]], grad_fn=<SigmoidBackward0>), 'y': 970.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(51.1012, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1075.1012, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0024, 0.6350]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(167.5968, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(400.4032, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.1852]], grad_fn=<SigmoidBackward0>), 'y': 568.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(143.5212, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(667.4788, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.3632]], grad_fn=<SigmoidBackward0>), 'y': 811.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(80.0213, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(449.9787, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.2182]], grad_fn=<SigmoidBackward0>), 'y': 530.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(81.7642, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(841.2358, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.4791]], grad_fn=<SigmoidBackward0>), 'y': 923.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(126.0381, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(512.9619, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.2602]], grad_fn=<SigmoidBackward0>), 'y': 639.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(15.5970, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(274.4030, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.1012]], grad_fn=<SigmoidBackward0>), 'y': 290.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(27.1987, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(661.1987, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.3590]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.0564, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(451.9436, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.2195]], grad_fn=<SigmoidBackward0>), 'y': 488.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.9299, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(821.9299, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.4662]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(84.7903, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(939.7903, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0030, 0.5448]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(48.5815, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(943.4185, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.5472]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(100.7830, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1040.7830, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.6121]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(49.9698, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(657.9698, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0032, 0.3569]], grad_fn=<SigmoidBackward0>), 'y': 607.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(102.9697, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(962.9697, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.5602]], grad_fn=<SigmoidBackward0>), 'y': 859.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(12.3946, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(946.3946, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.5492]], grad_fn=<SigmoidBackward0>), 'y': 933.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(107.2854, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(721.7146, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.3994]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(110.0573, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(712.9427, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0032, 0.3935]], grad_fn=<SigmoidBackward0>), 'y': 823.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(182.4797, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(435.5203, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.2086]], grad_fn=<SigmoidBackward0>), 'y': 618.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(135.0666, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(404.9334, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.1882]], grad_fn=<SigmoidBackward0>), 'y': 540.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(169.4241, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(668.5759, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.3640]], grad_fn=<SigmoidBackward0>), 'y': 838.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.5889, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(247.4111, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.0832]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(121.3979, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(417.6021, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.1966]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(66.7276, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(215.7276, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.0620]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(34.3272, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(523.6728, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.2674]], grad_fn=<SigmoidBackward0>), 'y': 558.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(161.8861, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1184.8861, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0025, 0.7082]], grad_fn=<SigmoidBackward0>), 'y': 1022.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(80.1880, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1047.1880, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.6163]], grad_fn=<SigmoidBackward0>), 'y': 966.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(24.8230, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(417.8230, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.1968]], grad_fn=<SigmoidBackward0>), 'y': 392.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(82.3438, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(816.3438, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.4625]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(11.8748, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(527.1252, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.2696]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(64.0721, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1004.0721, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.5876]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(5.3868, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(614.6132, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.3280]], grad_fn=<SigmoidBackward0>), 'y': 620.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(55.2443, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(651.2443, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.3524]], grad_fn=<SigmoidBackward0>), 'y': 595.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(52.6129, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(680.3871, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.3718]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(63.4362, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(726.5638, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.4026]], grad_fn=<SigmoidBackward0>), 'y': 790.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.1100, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(822.8900, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.4668]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(23.4096, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(497.5904, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.2500]], grad_fn=<SigmoidBackward0>), 'y': 521.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(10.3872, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1068.3872, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0032, 0.6305]], grad_fn=<SigmoidBackward0>), 'y': 1057.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(155.3125, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(294.3125, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.1144]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(66.4538, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(424.4538, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.2012]], grad_fn=<SigmoidBackward0>), 'y': 357.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(139.0072, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(991.0072, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0034, 0.5789]], grad_fn=<SigmoidBackward0>), 'y': 851.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(34.8112, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(766.8112, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.4295]], grad_fn=<SigmoidBackward0>), 'y': 731.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(96.0405, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1023.0405, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.6003]], grad_fn=<SigmoidBackward0>), 'y': 926.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(187.9821, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(883.0179, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.5069]], grad_fn=<SigmoidBackward0>), 'y': 1071.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(77.3316, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(901.6684, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.5194]], grad_fn=<SigmoidBackward0>), 'y': 979.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(224.5052, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(879.4948, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.5046]], grad_fn=<SigmoidBackward0>), 'y': 1104.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(103.4921, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(960.5079, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.5586]], grad_fn=<SigmoidBackward0>), 'y': 1064.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(46.3223, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(641.3223, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.3458]], grad_fn=<SigmoidBackward0>), 'y': 594.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(21.4602, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(706.4602, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.3892]], grad_fn=<SigmoidBackward0>), 'y': 684.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(57.2087, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(434.7913, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.2081]], grad_fn=<SigmoidBackward0>), 'y': 492.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(23.3253, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(255.3253, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.0884]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(41.6672, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(983.3328, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.5738]], grad_fn=<SigmoidBackward0>), 'y': 1025.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(111.0984, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(805.9016, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.4555]], grad_fn=<SigmoidBackward0>), 'y': 917.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(78.2475, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(893.2475, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.5138]], grad_fn=<SigmoidBackward0>), 'y': 814.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.3130, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(371.3130, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.1658]], grad_fn=<SigmoidBackward0>), 'y': 334.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(44.4332, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(328.4332, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0035, 0.1372]], grad_fn=<SigmoidBackward0>), 'y': 283.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.3276, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(995.6724, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.5820]], grad_fn=<SigmoidBackward0>), 'y': 1054.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(90.4001, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(240.4001, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.0785]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(46.8954, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(719.8954, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.3982]], grad_fn=<SigmoidBackward0>), 'y': 672.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(99.5800, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1015.4200, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.5952]], grad_fn=<SigmoidBackward0>), 'y': 1115.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(74.0697, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(285.0697, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.1083]], grad_fn=<SigmoidBackward0>), 'y': 210.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(45.1512, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(815.1512, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.4617]], grad_fn=<SigmoidBackward0>), 'y': 769.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(54.4405, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(236.4405, grad_fn=<AddBackward0>), 'output':
tensor([[0.0025, 0.0038, 0.0758]], grad_fn=<SigmoidBackward0>), 'y': 181.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(8.2145, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(828.7855, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.4708]], grad_fn=<SigmoidBackward0>), 'y': 837.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(32.2734, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(338.7266, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.1441]], grad_fn=<SigmoidBackward0>), 'y': 371.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(2.1743, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(436.1743, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.2090]], grad_fn=<SigmoidBackward0>), 'y': 433.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(25.4825, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1063.5175, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.6272]], grad_fn=<SigmoidBackward0>), 'y': 1089.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(11.3305, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(497.3305, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.2498]], grad_fn=<SigmoidBackward0>), 'y': 485.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(37.8390, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(427.1610, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.2030]], grad_fn=<SigmoidBackward0>), 'y': 465.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.1602, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1033.1602, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.6070]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(42.7177, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(388.2823, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.1771]], grad_fn=<SigmoidBackward0>), 'y': 431.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(51.0517, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(226.0517, grad_fn=<AddBackward0>), 'output':
tensor([[0.0024, 0.0039, 0.0689]], grad_fn=<SigmoidBackward0>), 'y': 174.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.5637, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(663.5637, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.3606]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(69.8043, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(218.8043, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.0641]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(91.9509, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(699.0491, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.3843]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(23.9388, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(256.0612, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.0890]], grad_fn=<SigmoidBackward0>), 'y': 280.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.0914, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(256.9086, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0034, 0.0895]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(54.8345, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(706.1655, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.3890]], grad_fn=<SigmoidBackward0>), 'y': 761.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(72.0692, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(930.0692, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0032, 0.5383]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.5572, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(714.5572, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.3946]], grad_fn=<SigmoidBackward0>), 'y': 682.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.9843, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(645.0157, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.3483]], grad_fn=<SigmoidBackward0>), 'y': 649.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(33.0699, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(365.9301, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.1622]], grad_fn=<SigmoidBackward0>), 'y': 399.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(40.2599, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(545.2599, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0032, 0.2817]], grad_fn=<SigmoidBackward0>), 'y': 504.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(7.7993, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(607.7993, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.3234]], grad_fn=<SigmoidBackward0>), 'y': 599.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(50.0173, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1074.0173, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0024, 0.6343]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.4882, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(409.5118, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.1913]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.9514, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(904.9514, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0034, 0.5215]], grad_fn=<SigmoidBackward0>), 'y': 874.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(110.1486, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(313.8514, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.1275]], grad_fn=<SigmoidBackward0>), 'y': 424.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(196.6907, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(567.3093, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.2964]], grad_fn=<SigmoidBackward0>), 'y': 764.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(20.2722, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(210.7278, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.0587]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(226.2083, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(774.7917, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.4348]], grad_fn=<SigmoidBackward0>), 'y': 1001.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(38.3620, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(233.3620, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0036, 0.0738]], grad_fn=<SigmoidBackward0>), 'y': 194.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(171.7582, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(531.2418, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.2724]], grad_fn=<SigmoidBackward0>), 'y': 703.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(59.6611, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(205.3389, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0037, 0.0551]], grad_fn=<SigmoidBackward0>), 'y': 265.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(168.8988, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(823.1012, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.4670]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(43.2162, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(613.7838, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.3274]], grad_fn=<SigmoidBackward0>), 'y': 657.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.8093, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(306.8093, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0034, 0.1228]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(42.4841, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(448.4841, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.2172]], grad_fn=<SigmoidBackward0>), 'y': 405.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(165.0353, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1252.0353, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.7529]], grad_fn=<SigmoidBackward0>), 'y': 1086.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(50.3608, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1144.3608, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.6811]], grad_fn=<SigmoidBackward0>), 'y': 1093.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(178.2399, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(317.2399, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.1297]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(171.9756, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(914.9756, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0026, 0.5283]], grad_fn=<SigmoidBackward0>), 'y': 742.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(20.4205, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(396.4205, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.1825]], grad_fn=<SigmoidBackward0>), 'y': 375.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.5721, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(463.4279, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.2272]], grad_fn=<SigmoidBackward0>), 'y': 500.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(44.8156, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(945.8156, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.5488]], grad_fn=<SigmoidBackward0>), 'y': 900.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(9.0913, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(358.0913, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.1570]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(148.8496, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(756.1504, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.4223]], grad_fn=<SigmoidBackward0>), 'y': 905.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(192.3169, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(750.6831, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.4187]], grad_fn=<SigmoidBackward0>), 'y': 943.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(154.0423, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(318.9577, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.1309]], grad_fn=<SigmoidBackward0>), 'y': 473.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(33.8030, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(245.1970, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.0817]], grad_fn=<SigmoidBackward0>), 'y': 279.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(222.8629, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(749.1371, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.4177]], grad_fn=<SigmoidBackward0>), 'y': 972.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(38.9724, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(352.0276, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0032, 0.1529]], grad_fn=<SigmoidBackward0>), 'y': 391.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(69.5059, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(242.5059, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0035, 0.0799]], grad_fn=<SigmoidBackward0>), 'y': 172.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(46.2657, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(295.2657, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.1151]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(25.6676, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(465.6676, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.2287]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.3939, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(305.3939, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.1218]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.8853, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(243.8853, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.0808]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.6575, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(258.6575, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.0907]], grad_fn=<SigmoidBackward0>), 'y': 244.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(42.4428, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(714.5572, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.3946]], grad_fn=<SigmoidBackward0>), 'y': 757.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(33.2704, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(935.2704, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.5417]], grad_fn=<SigmoidBackward0>), 'y': 901.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(180.4320, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(833.5680, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0032, 0.4740]], grad_fn=<SigmoidBackward0>), 'y': 1014.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(52.1968, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(563.8032, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.2941]], grad_fn=<SigmoidBackward0>), 'y': 616.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(16.5634, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(503.4366, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.2539]], grad_fn=<SigmoidBackward0>), 'y': 520.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(90.1161, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(967.1161, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.5630]], grad_fn=<SigmoidBackward0>), 'y': 876.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(103.6916, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(679.6916, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.3714]], grad_fn=<SigmoidBackward0>), 'y': 575.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(10.7581, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(956.2419, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.5557]], grad_fn=<SigmoidBackward0>), 'y': 967.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(32.6377, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(557.6377, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0032, 0.2900]], grad_fn=<SigmoidBackward0>), 'y': 524.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(123.1418, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(275.1418, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.1016]], grad_fn=<SigmoidBackward0>), 'y': 151.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.5129, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(990.5129, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.5786]], grad_fn=<SigmoidBackward0>), 'y': 960.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.3295, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1025.6705, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.6020]], grad_fn=<SigmoidBackward0>), 'y': 1065.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(108.3630, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(252.3630, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.0865]], grad_fn=<SigmoidBackward0>), 'y': 143.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(24.6371, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(670.3629, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.3652]], grad_fn=<SigmoidBackward0>), 'y': 695.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.6450, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(881.3550, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.5058]], grad_fn=<SigmoidBackward0>), 'y': 911.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(22.3146, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(942.3146, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.5465]], grad_fn=<SigmoidBackward0>), 'y': 919.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(5.2981, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1067.2981, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.6298]], grad_fn=<SigmoidBackward0>), 'y': 1061.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.3450, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(272.6550, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0034, 0.1000]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(11.5142, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(952.5142, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.5533]], grad_fn=<SigmoidBackward0>), 'y': 940.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(182.2757, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(310.2757, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0032, 0.1251]], grad_fn=<SigmoidBackward0>), 'y':
127.50000000000001}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(104.7335, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(811.2665, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.4591]], grad_fn=<SigmoidBackward0>), 'y': 916.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.2300, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(249.7700, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.0847]], grad_fn=<SigmoidBackward0>), 'y': 312.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(79.1832, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(428.8168, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.2041]], grad_fn=<SigmoidBackward0>), 'y': 508.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(90.4552, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(419.5448, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.1979]], grad_fn=<SigmoidBackward0>), 'y': 510.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(6.6708, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(396.6708, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.1827]], grad_fn=<SigmoidBackward0>), 'y': 389.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(107.4081, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(260.4081, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.0918]], grad_fn=<SigmoidBackward0>), 'y': 152.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(5.0972, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(354.0972, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.1543]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(25.9715, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(436.0285, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.2089]], grad_fn=<SigmoidBackward0>), 'y': 462.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(12.1437, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(625.1437, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.3350]], grad_fn=<SigmoidBackward0>), 'y': 612.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(26.6653, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(714.3347, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.3945]], grad_fn=<SigmoidBackward0>), 'y': 741.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(108.4724, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(755.5276, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0036, 0.4219]], grad_fn=<SigmoidBackward0>), 'y': 864.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(90.3354, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(988.3354, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.5771]], grad_fn=<SigmoidBackward0>), 'y': 897.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(74.7990, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(515.2010, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.2617]], grad_fn=<SigmoidBackward0>), 'y': 590.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.6259, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1009.3741, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.5912]], grad_fn=<SigmoidBackward0>), 'y': 1029.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(149.8449, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(971.1551, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.5657]], grad_fn=<SigmoidBackward0>), 'y': 1121.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(16.8204, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(578.8204, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.3041]], grad_fn=<SigmoidBackward0>), 'y': 561.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(120.6675, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(946.6675, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0032, 0.5494]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(140.9293, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(354.9293, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.1548]], grad_fn=<SigmoidBackward0>), 'y': 213.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(12.3801, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(550.6199, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.2853]], grad_fn=<SigmoidBackward0>), 'y': 563.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(165.5696, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1072.5696, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.6333]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(129.6309, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1218.6309, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.7307]], grad_fn=<SigmoidBackward0>), 'y': 1088.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(35.9760, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1028.9760, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.6042]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(28.1803, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(267.1803, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.0964]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(46.7476, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1027.2524, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.6031]], grad_fn=<SigmoidBackward0>), 'y': 1074.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(6.0856, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(500.9144, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.2522]], grad_fn=<SigmoidBackward0>), 'y': 507.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(69.6929, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(219.6929, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.0647]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(99.4871, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(837.4871, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.4766]], grad_fn=<SigmoidBackward0>), 'y': 737.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(5.0321, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(229.0321, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0030, 0.0709]], grad_fn=<SigmoidBackward0>), 'y': 223.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(69.7139, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(867.2861, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.4965]], grad_fn=<SigmoidBackward0>), 'y': 937.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(59.3950, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(769.6050, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.4313]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(33.2927, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(311.7073, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.1260]], grad_fn=<SigmoidBackward0>), 'y': 345.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.9590, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(889.9590, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.5116]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(9.4264, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(604.5736, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.3213]], grad_fn=<SigmoidBackward0>), 'y': 614.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.5634, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(288.5634, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.1106]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.7963, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(439.2037, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.2110]], grad_fn=<SigmoidBackward0>), 'y': 498.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(10.7938, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(300.2062, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0035, 0.1184]], grad_fn=<SigmoidBackward0>), 'y': 311.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(61.7381, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(290.7381, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.1121]], grad_fn=<SigmoidBackward0>), 'y': 228.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(50.5384, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(391.4616, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.1792]], grad_fn=<SigmoidBackward0>), 'y': 442.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(78.9744, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(357.9744, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.1569]], grad_fn=<SigmoidBackward0>), 'y': 278.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(77.0202, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(484.0202, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.2409]], grad_fn=<SigmoidBackward0>), 'y': 406.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(115.0850, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1135.0850, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.6750]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(8.9496, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(485.0504, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.2416]], grad_fn=<SigmoidBackward0>), 'y': 494.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(87.3008, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1069.3008, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.6311]], grad_fn=<SigmoidBackward0>), 'y': 981.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(88.4379, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(796.4379, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.4492]], grad_fn=<SigmoidBackward0>), 'y': 707.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(30.7987, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(248.7987, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0035, 0.0841]], grad_fn=<SigmoidBackward0>), 'y': 217.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(54.4722, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(851.5278, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.4859]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(14.1302, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(887.1302, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0032, 0.5097]], grad_fn=<SigmoidBackward0>), 'y': 872.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(142.2150, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(916.7850, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.5294]], grad_fn=<SigmoidBackward0>), 'y': 1059.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(38.4712, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(289.5288, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.1113]], grad_fn=<SigmoidBackward0>), 'y': 328.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(78.5870, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(591.4130, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.3125]], grad_fn=<SigmoidBackward0>), 'y': 670.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(50.6281, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(526.3719, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.2692]], grad_fn=<SigmoidBackward0>), 'y': 577.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(7.5502, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(294.4498, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.1145]], grad_fn=<SigmoidBackward0>), 'y': 302.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(49.6641, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(599.6641, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.3180]], grad_fn=<SigmoidBackward0>), 'y': 549.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(7.5092, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(250.4908, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.0852]], grad_fn=<SigmoidBackward0>), 'y': 258.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(88.8723, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(257.8723, grad_fn=<AddBackward0>), 'output':
tensor([[0.0022, 0.0034, 0.0901]], grad_fn=<SigmoidBackward0>), 'y': 168.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(9.4338, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(664.5662, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.3613]], grad_fn=<SigmoidBackward0>), 'y': 674.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(6.5045, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1023.5045, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.6006]], grad_fn=<SigmoidBackward0>), 'y': 1016.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.2129, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(845.2129, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0031, 0.4817]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(65.9720, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(710.9720, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.3922]], grad_fn=<SigmoidBackward0>), 'y': 644.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(137.7125, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1159.7125, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0024, 0.6914]], grad_fn=<SigmoidBackward0>), 'y': 1021.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(42.1002, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(437.8998, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.2102]], grad_fn=<SigmoidBackward0>), 'y': 480.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(144.8856, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(825.1144, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.4683]], grad_fn=<SigmoidBackward0>), 'y': 970.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(59.7979, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(963.2021, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0023, 0.5604]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(162.8653, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(405.1347, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0032, 0.1883]], grad_fn=<SigmoidBackward0>), 'y': 568.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(83.2487, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(727.7513, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.4034]], grad_fn=<SigmoidBackward0>), 'y': 811.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.0167, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(567.0167, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.2963]], grad_fn=<SigmoidBackward0>), 'y': 530.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(67.2217, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(991.2217, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.5791]], grad_fn=<SigmoidBackward0>), 'y': 923.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(12.0778, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(626.9222, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.3362]], grad_fn=<SigmoidBackward0>), 'y': 639.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(23.5375, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(314.5375, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0032, 0.1279]], grad_fn=<SigmoidBackward0>), 'y': 290.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(75.7556, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(709.7556, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.3914]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(9.9507, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(478.0493, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.2369]], grad_fn=<SigmoidBackward0>), 'y': 488.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(7.1660, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(799.1660, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.4510]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.5787, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(853.4213, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.4872]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(95.5264, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(896.4736, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.5159]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(63.6720, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1003.6720, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.5874]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(61.0670, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(669.0670, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0031, 0.3643]], grad_fn=<SigmoidBackward0>), 'y': 607.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(109.3154, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(969.3154, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.5645]], grad_fn=<SigmoidBackward0>), 'y': 859.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(30.5859, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(964.5859, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.5613]], grad_fn=<SigmoidBackward0>), 'y': 933.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(69.6584, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(759.3416, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.4245]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.5545, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(766.4455, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0031, 0.4292]], grad_fn=<SigmoidBackward0>), 'y': 823.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(123.2727, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(494.7273, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.2481]], grad_fn=<SigmoidBackward0>), 'y': 618.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(72.0512, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(467.9488, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.2302]], grad_fn=<SigmoidBackward0>), 'y': 540.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(61.4608, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(776.5392, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.4360]], grad_fn=<SigmoidBackward0>), 'y': 838.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(33.5132, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(282.5132, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.1066]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(38.7945, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(500.2055, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.2517]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(94.2288, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(243.2288, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.0804]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(63.0166, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(622.0166, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.3329]], grad_fn=<SigmoidBackward0>), 'y': 558.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(207.4004, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1230.4004, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0024, 0.7385]], grad_fn=<SigmoidBackward0>), 'y': 1022.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(79.8395, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1046.8395, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.6161]], grad_fn=<SigmoidBackward0>), 'y': 966.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(15.6609, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(408.6609, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0032, 0.1907]], grad_fn=<SigmoidBackward0>), 'y': 392.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(34.5326, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(768.5326, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.4306]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(66.7680, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(472.2320, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.2331]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.9622, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(876.0378, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.5023]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(69.5927, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(550.4073, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.2852]], grad_fn=<SigmoidBackward0>), 'y': 620.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(8.8561, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(604.8561, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.3215]], grad_fn=<SigmoidBackward0>), 'y': 595.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(82.6200, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(650.3800, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.3519]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(65.5409, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(724.4591, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.4012]], grad_fn=<SigmoidBackward0>), 'y': 790.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(42.9112, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(811.0888, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.4590]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(5.4491, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(527.4491, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.2699]], grad_fn=<SigmoidBackward0>), 'y': 521.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(7.6611, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1049.3389, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.6178]], grad_fn=<SigmoidBackward0>), 'y': 1057.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(157.4081, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(296.4081, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0033, 0.1158]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(86.2011, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(444.2011, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.2144]], grad_fn=<SigmoidBackward0>), 'y': 357.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(189.9130, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1041.9130, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0032, 0.6129]], grad_fn=<SigmoidBackward0>), 'y': 851.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(112.0609, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(844.0609, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.4810]], grad_fn=<SigmoidBackward0>), 'y': 731.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(169.0393, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1096.0393, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.6490]], grad_fn=<SigmoidBackward0>), 'y': 926.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(70.9241, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1000.0759, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.5850]], grad_fn=<SigmoidBackward0>), 'y': 1071.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(44.8154, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1024.8154, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.6015]], grad_fn=<SigmoidBackward0>), 'y': 979.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(157.1858, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(946.8142, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.5495]], grad_fn=<SigmoidBackward0>), 'y': 1104.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(59.6447, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1004.3553, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.5878]], grad_fn=<SigmoidBackward0>), 'y': 1064.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(51.0497, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(646.0497, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.3490]], grad_fn=<SigmoidBackward0>), 'y': 594.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(2.3491, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(681.6509, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.3727]], grad_fn=<SigmoidBackward0>), 'y': 684.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(49.0049, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(442.9951, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.2136]], grad_fn=<SigmoidBackward0>), 'y': 492.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.9918, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(261.9918, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.0929]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(6.1932, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1032.1932, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.6064]], grad_fn=<SigmoidBackward0>), 'y': 1025.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(113.4008, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(803.5992, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.4540]], grad_fn=<SigmoidBackward0>), 'y': 917.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(50.1868, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(865.1868, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.4951]], grad_fn=<SigmoidBackward0>), 'y': 814.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(5.0110, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(340.0110, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0031, 0.1449]], grad_fn=<SigmoidBackward0>), 'y': 334.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(12.8221, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(296.8221, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.1161]], grad_fn=<SigmoidBackward0>), 'y': 283.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(162.3405, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(891.6595, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.5127]], grad_fn=<SigmoidBackward0>), 'y': 1054.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.9875, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(208.9875, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.0576]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(66.1387, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(605.8613, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.3222]], grad_fn=<SigmoidBackward0>), 'y': 672.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(204.1086, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(910.8914, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.5255]], grad_fn=<SigmoidBackward0>), 'y': 1115.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(47.5394, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(258.5394, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.0906]], grad_fn=<SigmoidBackward0>), 'y': 210.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(2.0463, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(772.0463, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0031, 0.4329]], grad_fn=<SigmoidBackward0>), 'y': 769.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(50.2461, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(232.2461, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0036, 0.0730]], grad_fn=<SigmoidBackward0>), 'y': 181.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(25.3527, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(863.3527, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.4938]], grad_fn=<SigmoidBackward0>), 'y': 837.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(38.4690, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(332.5310, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.1399]], grad_fn=<SigmoidBackward0>), 'y': 371.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.9676, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(414.0324, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.1943]], grad_fn=<SigmoidBackward0>), 'y': 433.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(62.6023, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1026.3977, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.6025]], grad_fn=<SigmoidBackward0>), 'y': 1089.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(8.3229, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(494.3229, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0031, 0.2478]], grad_fn=<SigmoidBackward0>), 'y': 485.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(32.6216, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(432.3784, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0026, 0.2065]], grad_fn=<SigmoidBackward0>), 'y': 465.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(9.2189, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1009.7811, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.5915]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(5.1884, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(425.8116, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.2021]], grad_fn=<SigmoidBackward0>), 'y': 431.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(79.1293, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(254.1293, grad_fn=<AddBackward0>), 'output':
tensor([[0.0023, 0.0037, 0.0876]], grad_fn=<SigmoidBackward0>), 'y': 174.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(182.7702, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(816.7702, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.4628]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(126.2047, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(275.2047, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.1017]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(138.9070, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(930.9070, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.5389]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(68.3884, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(349.3884, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.1512]], grad_fn=<SigmoidBackward0>), 'y': 280.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(37.1161, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(324.1161, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0033, 0.1343]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(48.7696, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(810.7696, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.4588]], grad_fn=<SigmoidBackward0>), 'y': 761.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(70.8153, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(928.8153, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.5375]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.6789, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(642.3211, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.3465]], grad_fn=<SigmoidBackward0>), 'y': 682.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(105.3824, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(543.6176, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.2807]], grad_fn=<SigmoidBackward0>), 'y': 649.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(107.2585, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(291.7415, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.1128]], grad_fn=<SigmoidBackward0>), 'y': 399.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(91.5137, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(412.4863, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.1932]], grad_fn=<SigmoidBackward0>), 'y': 504.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(137.6002, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(461.3998, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.2259]], grad_fn=<SigmoidBackward0>), 'y': 599.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(89.5056, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(933.4944, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0022, 0.5406]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(49.6030, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(389.3970, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.1779]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(67.8468, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(942.8468, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0033, 0.5468]], grad_fn=<SigmoidBackward0>), 'y': 874.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(43.3084, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(380.6916, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.1721]], grad_fn=<SigmoidBackward0>), 'y': 424.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(24.1088, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(739.8912, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.4115]], grad_fn=<SigmoidBackward0>), 'y': 764.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.7452, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(288.7452, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.1107]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(75.1560, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1077.1560, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.6364]], grad_fn=<SigmoidBackward0>), 'y': 1001.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(148.6503, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(343.6503, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.1473]], grad_fn=<SigmoidBackward0>), 'y': 194.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(98.2755, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(802.2755, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.4531]], grad_fn=<SigmoidBackward0>), 'y': 703.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.7917, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(261.2083, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0035, 0.0924]], grad_fn=<SigmoidBackward0>), 'y': 265.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(2.0690, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(995.0690, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0027, 0.5816]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(41.9912, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(699.9912, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.3849]], grad_fn=<SigmoidBackward0>), 'y': 657.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.7594, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(282.2406, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0032, 0.1064]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(52.0816, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(352.9184, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.1535]], grad_fn=<SigmoidBackward0>), 'y': 405.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.0612, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1054.9388, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.6215]], grad_fn=<SigmoidBackward0>), 'y': 1086.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(177.3323, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(915.6677, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.5287]], grad_fn=<SigmoidBackward0>), 'y': 1093.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(106.0097, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(245.0097, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0032, 0.0816]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(14.1390, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(757.1390, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0024, 0.4230]], grad_fn=<SigmoidBackward0>), 'y': 742.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(44.6082, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(330.3918, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.1385]], grad_fn=<SigmoidBackward0>), 'y': 375.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(59.5625, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(440.4375, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.2119]], grad_fn=<SigmoidBackward0>), 'y': 500.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(20.0692, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(921.0692, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.5323]], grad_fn=<SigmoidBackward0>), 'y': 900.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(22.9347, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(371.9347, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.1662]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(71.2801, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(833.7199, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.4741]], grad_fn=<SigmoidBackward0>), 'y': 905.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(79.3417, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(863.6583, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0032, 0.4940]], grad_fn=<SigmoidBackward0>), 'y': 943.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(53.7406, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(419.2594, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.1978]], grad_fn=<SigmoidBackward0>), 'y': 473.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(41.8738, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(321.8738, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.1328]], grad_fn=<SigmoidBackward0>), 'y': 279.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(10.1887, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(961.8113, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.5595]], grad_fn=<SigmoidBackward0>), 'y': 972.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(104.8280, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(496.8280, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.2495]], grad_fn=<SigmoidBackward0>), 'y': 391.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(137.7837, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(310.7837, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.1254]], grad_fn=<SigmoidBackward0>), 'y': 172.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(122.5542, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(371.5542, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.1659]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(151.4897, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(591.4897, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.3126]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(107.2148, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(356.2148, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.1557]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.3398, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(270.3398, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.0985]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(32.3749, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(277.3749, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0033, 0.1032]], grad_fn=<SigmoidBackward0>), 'y': 244.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(1.0791, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(755.9209, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0031, 0.4222]], grad_fn=<SigmoidBackward0>), 'y': 757.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(47.7137, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(949.7137, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.5514]], grad_fn=<SigmoidBackward0>), 'y': 901.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(183.7512, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(830.2488, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0030, 0.4718]], grad_fn=<SigmoidBackward0>), 'y': 1014.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(55.7624, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(560.2376, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.2917]], grad_fn=<SigmoidBackward0>), 'y': 616.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(25.9599, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(494.0401, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.2476]], grad_fn=<SigmoidBackward0>), 'y': 520.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(50.4113, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(927.4113, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.5365]], grad_fn=<SigmoidBackward0>), 'y': 876.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(59.3011, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(635.3011, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0031, 0.3418]], grad_fn=<SigmoidBackward0>), 'y': 575.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(80.9291, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(886.0709, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.5090]], grad_fn=<SigmoidBackward0>), 'y': 967.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.7507, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(505.2493, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.2551]], grad_fn=<SigmoidBackward0>), 'y': 524.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(107.3663, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(259.3663, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.0911]], grad_fn=<SigmoidBackward0>), 'y': 151.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.9390, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(974.9390, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.5682]], grad_fn=<SigmoidBackward0>), 'y': 960.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(12.3430, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1052.6570, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.6200]], grad_fn=<SigmoidBackward0>), 'y': 1065.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(120.1276, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(264.1276, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.0943]], grad_fn=<SigmoidBackward0>), 'y': 143.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(61.8291, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(757.8291, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.4235]], grad_fn=<SigmoidBackward0>), 'y': 695.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(6.6094, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(904.3906, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.5212]], grad_fn=<SigmoidBackward0>), 'y': 911.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(20.7775, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(940.7775, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.5454]], grad_fn=<SigmoidBackward0>), 'y': 919.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.3127, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1057.6873, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.6234]], grad_fn=<SigmoidBackward0>), 'y': 1061.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(10.8763, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(275.1237, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0032, 0.1017]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(33.3733, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(974.3733, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.5678]], grad_fn=<SigmoidBackward0>), 'y': 940.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(202.3062, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(330.3062, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.1384]], grad_fn=<SigmoidBackward0>), 'y':
127.50000000000001}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.5150, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(876.4850, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.5026]], grad_fn=<SigmoidBackward0>), 'y': 916.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.9200, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(280.0800, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.1050]], grad_fn=<SigmoidBackward0>), 'y': 312.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(20.3405, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(529.3405, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.2712]], grad_fn=<SigmoidBackward0>), 'y': 508.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.8517, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(496.1483, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.2490]], grad_fn=<SigmoidBackward0>), 'y': 510.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(46.5558, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(436.5558, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0031, 0.2093]], grad_fn=<SigmoidBackward0>), 'y': 389.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(121.4975, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(274.4975, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.1012]], grad_fn=<SigmoidBackward0>), 'y': 152.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(11.3804, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(360.3804, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.1585]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(8.2270, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(453.7730, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.2208]], grad_fn=<SigmoidBackward0>), 'y': 462.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(17.7559, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(630.7559, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.3388]], grad_fn=<SigmoidBackward0>), 'y': 612.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(37.5950, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(703.4050, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0024, 0.3872]], grad_fn=<SigmoidBackward0>), 'y': 741.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(134.8185, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(729.1815, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.4043]], grad_fn=<SigmoidBackward0>), 'y': 864.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(55.0844, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(953.0844, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.5536]], grad_fn=<SigmoidBackward0>), 'y': 897.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(97.2838, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(492.7162, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.2467]], grad_fn=<SigmoidBackward0>), 'y': 590.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(64.3196, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(964.6804, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.5614]], grad_fn=<SigmoidBackward0>), 'y': 1029.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(206.5762, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(914.4238, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.5279]], grad_fn=<SigmoidBackward0>), 'y': 1121.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(30.1610, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(530.8390, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.2722]], grad_fn=<SigmoidBackward0>), 'y': 561.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(87.1464, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(913.1464, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0030, 0.5270]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(137.7980, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(351.7980, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0032, 0.1528]], grad_fn=<SigmoidBackward0>), 'y': 213.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(26.4865, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(590.4865, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.3119]], grad_fn=<SigmoidBackward0>), 'y': 563.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(183.1664, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1090.1664, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.6450]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(137.1235, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1226.1235, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.7357]], grad_fn=<SigmoidBackward0>), 'y': 1088.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(20.9929, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1013.9929, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.5943]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(15.3098, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(254.3098, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.0878]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.4191, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1011.5809, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.5926]], grad_fn=<SigmoidBackward0>), 'y': 1074.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(22.2686, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(484.7314, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.2414]], grad_fn=<SigmoidBackward0>), 'y': 507.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(57.1675, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(207.1675, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.0563]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(28.7258, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(766.7258, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.4294]], grad_fn=<SigmoidBackward0>), 'y': 737.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.0412, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(209.9588, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.0582]], grad_fn=<SigmoidBackward0>), 'y': 223.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(127.2039, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(809.7961, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.4581]], grad_fn=<SigmoidBackward0>), 'y': 937.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(115.5922, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(713.4078, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.3939]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.8452, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(288.1548, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0031, 0.1104]], grad_fn=<SigmoidBackward0>), 'y': 345.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(9.3392, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(847.6608, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.4834]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(6.0454, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(621.0454, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.3323]], grad_fn=<SigmoidBackward0>), 'y': 614.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.8557, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(288.8557, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.1108]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(30.0626, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(467.9374, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0031, 0.2302]], grad_fn=<SigmoidBackward0>), 'y': 498.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.0191, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(311.6955, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0033, 0.1260]], grad_fn=<SigmoidBackward0>), 'y': 311.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(61.1751, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(290.1751, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.1117]], grad_fn=<SigmoidBackward0>), 'y': 228.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(48.4256, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(393.5744, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.1806]], grad_fn=<SigmoidBackward0>), 'y': 442.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(75.3718, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(354.3718, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.1545]], grad_fn=<SigmoidBackward0>), 'y': 278.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(68.0418, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(475.0418, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.2350]], grad_fn=<SigmoidBackward0>), 'y': 406.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(99.3939, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1119.3939, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.6645]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(9.7577, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(484.2423, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.2411]], grad_fn=<SigmoidBackward0>), 'y': 494.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(59.7009, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1041.7009, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.6127]], grad_fn=<SigmoidBackward0>), 'y': 981.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.8025, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(764.8025, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.4281]], grad_fn=<SigmoidBackward0>), 'y': 707.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(17.5620, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(235.5620, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.0753]], grad_fn=<SigmoidBackward0>), 'y': 217.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(92.1305, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(813.8695, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.4608]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(17.3697, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(854.6303, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.4880]], grad_fn=<SigmoidBackward0>), 'y': 872.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(110.3023, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(948.6977, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.5507]], grad_fn=<SigmoidBackward0>), 'y': 1059.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.2625, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(308.7375, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.1241]], grad_fn=<SigmoidBackward0>), 'y': 328.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(17.5392, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(688.5392, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.3773]], grad_fn=<SigmoidBackward0>), 'y': 670.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(20.8444, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(598.8444, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0032, 0.3175]], grad_fn=<SigmoidBackward0>), 'y': 577.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.9855, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(307.9855, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0032, 0.1236]], grad_fn=<SigmoidBackward0>), 'y': 302.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(14.4424, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(564.4424, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0026, 0.2946]], grad_fn=<SigmoidBackward0>), 'y': 549.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.2512, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(218.7488, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0031, 0.0641]], grad_fn=<SigmoidBackward0>), 'y': 258.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(43.1527, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(212.1527, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.0597]], grad_fn=<SigmoidBackward0>), 'y': 168.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(180.3996, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(493.6004, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.2473]], grad_fn=<SigmoidBackward0>), 'y': 674.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(249.5854, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(766.4146, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.4292]], grad_fn=<SigmoidBackward0>), 'y': 1016.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(221.0881, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(603.9119, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.3209]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(110.3364, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(533.6636, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.2741]], grad_fn=<SigmoidBackward0>), 'y': 644.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.7720, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1084.7720, grad_fn=<AddBackward0>), 'output':
tensor([[0.0012, 0.0023, 0.6415]], grad_fn=<SigmoidBackward0>), 'y': 1021.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(42.7539, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(437.2461, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.2098]], grad_fn=<SigmoidBackward0>), 'y': 480.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(66.7520, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(903.2480, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.5204]], grad_fn=<SigmoidBackward0>), 'y': 970.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(97.2917, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1121.2917, grad_fn=<AddBackward0>), 'output':
tensor([[0.0012, 0.0022, 0.6658]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(63.7623, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(504.2377, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.2544]], grad_fn=<SigmoidBackward0>), 'y': 568.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(77.6671, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(889.6671, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.5114]], grad_fn=<SigmoidBackward0>), 'y': 811.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(143.1450, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(674.1450, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.3677]], grad_fn=<SigmoidBackward0>), 'y': 530.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(151.8152, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1075.8152, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.6355]], grad_fn=<SigmoidBackward0>), 'y': 923.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(35.5593, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(675.5593, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.3686]], grad_fn=<SigmoidBackward0>), 'y': 639.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(8.0211, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(299.0211, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0030, 0.1176]], grad_fn=<SigmoidBackward0>), 'y': 290.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(16.3260, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(616.6740, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.3294]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(77.3021, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(410.6979, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.1920]], grad_fn=<SigmoidBackward0>), 'y': 488.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(126.4391, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(664.5609, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.3613]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(88.7850, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(765.2150, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.4284]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(155.5263, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(836.4737, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.4759]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(38.4767, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(978.4767, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.5706]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(50.0640, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(658.0640, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.3570]], grad_fn=<SigmoidBackward0>), 'y': 607.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(139.2780, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(999.2780, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.5844]], grad_fn=<SigmoidBackward0>), 'y': 859.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(73.5865, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1007.5865, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0024, 0.5900]], grad_fn=<SigmoidBackward0>), 'y': 933.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.4926, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(825.5074, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.4686]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.7446, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(855.7446, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0029, 0.4888]], grad_fn=<SigmoidBackward0>), 'y': 823.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(91.1713, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(526.8287, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.2695]], grad_fn=<SigmoidBackward0>), 'y': 618.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(57.2083, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(482.7917, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.2401]], grad_fn=<SigmoidBackward0>), 'y': 540.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(78.7558, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(759.2442, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0024, 0.4244]], grad_fn=<SigmoidBackward0>), 'y': 838.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.7295, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(262.7295, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.0934]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(80.1557, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(458.8443, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.2242]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(70.8736, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(219.8736, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.0648]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(23.2777, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(534.7223, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.2747]], grad_fn=<SigmoidBackward0>), 'y': 558.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(156.4482, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1179.4482, grad_fn=<AddBackward0>), 'output':
tensor([[0.0012, 0.0022, 0.7046]], grad_fn=<SigmoidBackward0>), 'y': 1022.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(44.7762, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1011.7762, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.5928]], grad_fn=<SigmoidBackward0>), 'y': 966.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(1.3927, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(390.6073, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0030, 0.1787]], grad_fn=<SigmoidBackward0>), 'y': 392.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(59.5595, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(793.5595, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.4473]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(6.1107, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(532.8893, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.2735]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(57.1145, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(997.1145, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.5830]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.6183, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(640.6183, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.3453]], grad_fn=<SigmoidBackward0>), 'y': 620.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(51.0515, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(647.0515, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.3496]], grad_fn=<SigmoidBackward0>), 'y': 595.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(92.2292, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(640.7708, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.3455]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(118.6412, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(671.3588, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.3658]], grad_fn=<SigmoidBackward0>), 'y': 790.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(139.9670, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(714.0330, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.3943]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(97.8686, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(423.1314, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.2003]], grad_fn=<SigmoidBackward0>), 'y': 521.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(113.2964, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(943.7036, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.5474]], grad_fn=<SigmoidBackward0>), 'y': 1057.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(110.9212, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(249.9212, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.0849]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.8383, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(358.8383, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.1575]], grad_fn=<SigmoidBackward0>), 'y': 357.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(71.7841, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(923.7841, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0031, 0.5341]], grad_fn=<SigmoidBackward0>), 'y': 851.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(10.3754, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(720.6246, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.3987]], grad_fn=<SigmoidBackward0>), 'y': 731.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(107.6545, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1034.6545, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.6080]], grad_fn=<SigmoidBackward0>), 'y': 926.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(58.4330, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1012.5670, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.5933]], grad_fn=<SigmoidBackward0>), 'y': 1071.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(84.2643, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1064.2643, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.6278]], grad_fn=<SigmoidBackward0>), 'y': 979.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.8958, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1041.1042, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.6123]], grad_fn=<SigmoidBackward0>), 'y': 1104.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(71.4490, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1136.4490, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.6759]], grad_fn=<SigmoidBackward0>), 'y': 1064.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(150.8741, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(745.8741, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.4155]], grad_fn=<SigmoidBackward0>), 'y': 594.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(95.9802, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(780.9802, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.4389]], grad_fn=<SigmoidBackward0>), 'y': 684.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(21.8808, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(470.1192, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.2317]], grad_fn=<SigmoidBackward0>), 'y': 492.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(15.6200, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(247.6200, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.0833]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(84.9498, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(940.0502, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0024, 0.5450]], grad_fn=<SigmoidBackward0>), 'y': 1025.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(182.3805, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(734.6195, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.4080]], grad_fn=<SigmoidBackward0>), 'y': 917.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.7516, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(782.2484, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.4398]], grad_fn=<SigmoidBackward0>), 'y': 814.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.0023, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(334.5685, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.1413]], grad_fn=<SigmoidBackward0>), 'y': 334.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(37.8988, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(321.8988, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0032, 0.1328]], grad_fn=<SigmoidBackward0>), 'y': 283.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.0858, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1014.9142, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.5948]], grad_fn=<SigmoidBackward0>), 'y': 1054.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(100.3910, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(250.3910, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.0852]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(136.3025, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(809.3025, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.4578]], grad_fn=<SigmoidBackward0>), 'y': 672.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(1.9639, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1113.0361, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.6603]], grad_fn=<SigmoidBackward0>), 'y': 1115.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(117.6697, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(328.6697, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0032, 0.1374]], grad_fn=<SigmoidBackward0>), 'y': 210.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(166.4056, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(936.4056, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0030, 0.5425]], grad_fn=<SigmoidBackward0>), 'y': 769.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(98.4325, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(280.4325, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0034, 0.1052]], grad_fn=<SigmoidBackward0>), 'y': 181.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(168.7302, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1006.7302, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0024, 0.5894]], grad_fn=<SigmoidBackward0>), 'y': 837.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.4477, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(403.4477, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.1872]], grad_fn=<SigmoidBackward0>), 'y': 371.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(44.8686, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(478.8686, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.2375]], grad_fn=<SigmoidBackward0>), 'y': 433.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(41.6079, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1047.3921, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.6165]], grad_fn=<SigmoidBackward0>), 'y': 1089.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.5725, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(465.4275, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.2285]], grad_fn=<SigmoidBackward0>), 'y': 485.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(72.5986, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(392.4014, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0025, 0.1799]], grad_fn=<SigmoidBackward0>), 'y': 465.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(99.3370, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(919.6630, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0025, 0.5314]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(67.8200, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(363.1800, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.1604]], grad_fn=<SigmoidBackward0>), 'y': 431.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(44.2415, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(219.2415, grad_fn=<AddBackward0>), 'output':
tensor([[0.0021, 0.0035, 0.0644]], grad_fn=<SigmoidBackward0>), 'y': 174.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(44.9593, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(678.9593, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.3709]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(78.7848, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(227.7848, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.0701]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(25.9830, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(765.0170, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.4283]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(14.7867, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(295.7867, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.1155]], grad_fn=<SigmoidBackward0>), 'y': 280.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.9250, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(290.9250, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0031, 0.1122]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(11.6214, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(773.6214, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.4340]], grad_fn=<SigmoidBackward0>), 'y': 761.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(76.7484, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(934.7484, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.5414]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.8831, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(681.1169, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.3723]], grad_fn=<SigmoidBackward0>), 'y': 682.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(42.9639, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(606.0361, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0024, 0.3223]], grad_fn=<SigmoidBackward0>), 'y': 649.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(60.7844, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(338.2156, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.1437]], grad_fn=<SigmoidBackward0>), 'y': 399.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(2.0413, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(507.0413, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.2563]], grad_fn=<SigmoidBackward0>), 'y': 504.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(45.5955, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(553.4045, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.2872]], grad_fn=<SigmoidBackward0>), 'y': 599.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(32.9197, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1056.9197, grad_fn=<AddBackward0>), 'output':
tensor([[0.0012, 0.0021, 0.6229]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(16.1016, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(422.8984, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.2002]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(73.6760, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(948.6760, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0031, 0.5507]], grad_fn=<SigmoidBackward0>), 'y': 874.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(65.8747, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(358.1253, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.1570]], grad_fn=<SigmoidBackward0>), 'y': 424.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(109.1266, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(654.8734, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.3548]], grad_fn=<SigmoidBackward0>), 'y': 764.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(9.6355, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(241.6355, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.0793]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(86.7226, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(914.2774, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.5278]], grad_fn=<SigmoidBackward0>), 'y': 1001.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(86.3888, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(281.3888, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.1058]], grad_fn=<SigmoidBackward0>), 'y': 194.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.3534, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(683.6466, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.3740]], grad_fn=<SigmoidBackward0>), 'y': 703.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(21.3242, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(243.6758, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0033, 0.0807]], grad_fn=<SigmoidBackward0>), 'y': 265.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(12.4308, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1005.4308, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.5886]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(108.0450, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(766.0450, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.4290]], grad_fn=<SigmoidBackward0>), 'y': 657.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(45.7765, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(332.7765, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0031, 0.1401]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.9516, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(445.9516, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.2156]], grad_fn=<SigmoidBackward0>), 'y': 405.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(97.0315, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1184.0315, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.7076]], grad_fn=<SigmoidBackward0>), 'y': 1086.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(95.4478, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(997.5522, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.5833]], grad_fn=<SigmoidBackward0>), 'y': 1093.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(113.6197, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(252.6197, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.0867]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.8917, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(737.1083, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0023, 0.4097]], grad_fn=<SigmoidBackward0>), 'y': 742.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(52.8104, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(322.1896, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.1331]], grad_fn=<SigmoidBackward0>), 'y': 375.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(55.6123, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(444.3877, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.2145]], grad_fn=<SigmoidBackward0>), 'y': 500.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(25.6997, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(926.6997, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.5361]], grad_fn=<SigmoidBackward0>), 'y': 900.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(27.0837, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(376.0837, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.1690]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(44.2107, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(860.7893, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.4921]], grad_fn=<SigmoidBackward0>), 'y': 905.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.3184, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(884.6816, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0030, 0.5080]], grad_fn=<SigmoidBackward0>), 'y': 943.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(25.0279, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(447.9721, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.2169]], grad_fn=<SigmoidBackward0>), 'y': 473.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.3443, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(338.3443, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.1438]], grad_fn=<SigmoidBackward0>), 'y': 279.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(34.2216, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1007.2216, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.5897]], grad_fn=<SigmoidBackward0>), 'y': 972.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(100.0308, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(492.0308, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.2463]], grad_fn=<SigmoidBackward0>), 'y': 391.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(118.2077, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(291.2077, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0032, 0.1124]], grad_fn=<SigmoidBackward0>), 'y': 172.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(72.8216, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(321.8216, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.1328]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.8226, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(498.8226, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.2508]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.9470, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(285.9470, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.1089]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.9000, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(219.1000, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.0643]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(20.2228, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(223.7772, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0031, 0.0674]], grad_fn=<SigmoidBackward0>), 'y': 244.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(136.3552, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(620.6448, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.3320]], grad_fn=<SigmoidBackward0>), 'y': 757.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(88.0157, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(812.9843, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.4602]], grad_fn=<SigmoidBackward0>), 'y': 901.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(256.1935, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(757.8065, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.4235]], grad_fn=<SigmoidBackward0>), 'y': 1014.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(61.5236, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(554.4764, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.2879]], grad_fn=<SigmoidBackward0>), 'y': 616.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.9166, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(519.0834, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.2643]], grad_fn=<SigmoidBackward0>), 'y': 520.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(127.1241, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1004.1241, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.5877]], grad_fn=<SigmoidBackward0>), 'y': 876.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(172.7038, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(748.7038, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0030, 0.4174]], grad_fn=<SigmoidBackward0>), 'y': 575.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(63.7677, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1031.7677, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.6061]], grad_fn=<SigmoidBackward0>), 'y': 967.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(95.3403, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(620.3403, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0029, 0.3318]], grad_fn=<SigmoidBackward0>), 'y': 524.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(128.2191, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(280.2191, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.1051]], grad_fn=<SigmoidBackward0>), 'y': 151.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.1087, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(980.1087, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0031, 0.5717]], grad_fn=<SigmoidBackward0>), 'y': 960.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(38.3270, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1026.6730, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0030, 0.6027]], grad_fn=<SigmoidBackward0>), 'y': 1065.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(93.8409, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(237.8409, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.0768]], grad_fn=<SigmoidBackward0>), 'y': 143.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(49.8488, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(645.1512, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.3484]], grad_fn=<SigmoidBackward0>), 'y': 695.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(99.5007, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(811.4993, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.4593]], grad_fn=<SigmoidBackward0>), 'y': 911.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(66.3858, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(852.6142, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.4867]], grad_fn=<SigmoidBackward0>), 'y': 919.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(16.6226, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1044.3774, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.6145]], grad_fn=<SigmoidBackward0>), 'y': 1061.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(2.0272, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(283.9728, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0030, 0.1076]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(103.8621, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1044.8621, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.6149]], grad_fn=<SigmoidBackward0>), 'y': 940.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(262.3418, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(390.3418, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.1785]], grad_fn=<SigmoidBackward0>), 'y':
127.50000000000001}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(138.9230, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1055.9230, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.6222]], grad_fn=<SigmoidBackward0>), 'y': 916.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.9588, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(349.9588, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0031, 0.1516]], grad_fn=<SigmoidBackward0>), 'y': 312.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(134.2908, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(643.2908, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.3471]], grad_fn=<SigmoidBackward0>), 'y': 508.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(65.2838, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(576.2838, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.3025]], grad_fn=<SigmoidBackward0>), 'y': 510.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(52.0424, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(442.0424, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.2130]], grad_fn=<SigmoidBackward0>), 'y': 389.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(99.6537, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(252.6537, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.0867]], grad_fn=<SigmoidBackward0>), 'y': 152.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(45.2095, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(302.7905, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0027, 0.1201]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(92.3924, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(369.6076, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.1647]], grad_fn=<SigmoidBackward0>), 'y': 462.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(123.6035, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(488.3965, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.2439]], grad_fn=<SigmoidBackward0>), 'y': 612.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(167.3334, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(573.6666, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0023, 0.3007]], grad_fn=<SigmoidBackward0>), 'y': 741.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(257.2247, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(606.7753, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0032, 0.3228]], grad_fn=<SigmoidBackward0>), 'y': 864.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(75.0175, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(821.9825, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.4662]], grad_fn=<SigmoidBackward0>), 'y': 897.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(141.2702, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(448.7298, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.2174]], grad_fn=<SigmoidBackward0>), 'y': 590.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(82.1688, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(946.8312, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.5495]], grad_fn=<SigmoidBackward0>), 'y': 1029.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(167.2632, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(953.7368, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.5541]], grad_fn=<SigmoidBackward0>), 'y': 1121.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(40.9661, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(602.9661, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.3203]], grad_fn=<SigmoidBackward0>), 'y': 561.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(162.3858, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(988.3858, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.5772]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(163.8372, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(377.8372, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.1701]], grad_fn=<SigmoidBackward0>), 'y': 213.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(81.4414, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(645.4414, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.3486]], grad_fn=<SigmoidBackward0>), 'y': 563.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(239.8821, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1146.8821, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.6829]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(173.4880, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1262.4880, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.7599]], grad_fn=<SigmoidBackward0>), 'y': 1088.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(54.5059, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1047.5059, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.6166]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(24.5808, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(263.5808, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.0940]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.5684, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1060.4316, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.6252]], grad_fn=<SigmoidBackward0>), 'y': 1074.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.1525, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(512.1525, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.2597]], grad_fn=<SigmoidBackward0>), 'y': 507.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(53.6985, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(203.6985, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.0540]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(14.5424, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(722.4576, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0023, 0.3999]], grad_fn=<SigmoidBackward0>), 'y': 737.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(21.2130, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(201.7870, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0027, 0.0528]], grad_fn=<SigmoidBackward0>), 'y': 223.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(144.2419, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(792.7581, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.4468]], grad_fn=<SigmoidBackward0>), 'y': 937.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(106.1037, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(722.8963, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.4002]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(53.0922, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(291.9078, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0030, 0.1129]], grad_fn=<SigmoidBackward0>), 'y': 345.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(21.1450, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(879.1450, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.5044]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.1864, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(610.8136, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.3255]], grad_fn=<SigmoidBackward0>), 'y': 614.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(33.6912, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(282.6912, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.1067]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.1173, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(468.8827, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.2308]], grad_fn=<SigmoidBackward0>), 'y': 498.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.3550, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(312.3426, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0031, 0.1265]], grad_fn=<SigmoidBackward0>), 'y': 311.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(60.5700, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(289.5700, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.1113]], grad_fn=<SigmoidBackward0>), 'y': 228.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(43.3349, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(398.6651, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.1840]], grad_fn=<SigmoidBackward0>), 'y': 442.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(74.7494, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(353.7494, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.1541]], grad_fn=<SigmoidBackward0>), 'y': 278.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(67.1588, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(474.1588, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.2344]], grad_fn=<SigmoidBackward0>), 'y': 406.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(111.7162, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1131.7162, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0024, 0.6728]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(1.3462, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(496.3462, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.2491]], grad_fn=<SigmoidBackward0>), 'y': 494.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.2444, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1013.2444, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.5938]], grad_fn=<SigmoidBackward0>), 'y': 981.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.1099, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(707.9689, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0024, 0.3903]], grad_fn=<SigmoidBackward0>), 'y': 707.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.0083, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(212.9917, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0032, 0.0602]], grad_fn=<SigmoidBackward0>), 'y': 217.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(156.7113, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(749.2887, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.4178]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(89.9404, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(782.0596, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.4396]], grad_fn=<SigmoidBackward0>), 'y': 872.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(179.2539, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(879.7461, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.5048]], grad_fn=<SigmoidBackward0>), 'y': 1059.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.1535, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(271.8465, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.0995]], grad_fn=<SigmoidBackward0>), 'y': 328.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(72.8095, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(597.1905, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.3164]], grad_fn=<SigmoidBackward0>), 'y': 670.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(22.1687, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(554.8313, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0030, 0.2881]], grad_fn=<SigmoidBackward0>), 'y': 577.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(15.0889, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(318.0889, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0030, 0.1303]], grad_fn=<SigmoidBackward0>), 'y': 302.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(125.5403, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(675.5403, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0025, 0.3686]], grad_fn=<SigmoidBackward0>), 'y': 549.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(7.2164, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(266.2164, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0030, 0.0957]], grad_fn=<SigmoidBackward0>), 'y': 258.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(103.0596, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(272.0596, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.0996]], grad_fn=<SigmoidBackward0>), 'y': 168.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(46.9380, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(721.9380, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.3996]], grad_fn=<SigmoidBackward0>), 'y': 674.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.0098, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1016.3599, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.5958]], grad_fn=<SigmoidBackward0>), 'y': 1016.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(16.2110, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(808.7890, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.4575]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.7225, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(703.7225, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0025, 0.3874]], grad_fn=<SigmoidBackward0>), 'y': 644.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(163.0778, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1185.0778, grad_fn=<AddBackward0>), 'output':
tensor([[0.0011, 0.0022, 0.7083]], grad_fn=<SigmoidBackward0>), 'y': 1021.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(16.4296, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(463.5704, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.2273]], grad_fn=<SigmoidBackward0>), 'y': 480.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(80.2254, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(889.7746, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.5114]], grad_fn=<SigmoidBackward0>), 'y': 970.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(34.5048, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1058.5048, grad_fn=<AddBackward0>), 'output':
tensor([[0.0011, 0.0021, 0.6240]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(134.3605, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(433.6395, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.2074]], grad_fn=<SigmoidBackward0>), 'y': 568.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(65.2266, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(745.7734, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.4155]], grad_fn=<SigmoidBackward0>), 'y': 811.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(26.8577, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(557.8577, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.2902]], grad_fn=<SigmoidBackward0>), 'y': 530.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.7386, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(963.7386, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.5608]], grad_fn=<SigmoidBackward0>), 'y': 923.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(59.2271, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(579.7729, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0025, 0.3048]], grad_fn=<SigmoidBackward0>), 'y': 639.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.6454, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(271.3546, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.0992]], grad_fn=<SigmoidBackward0>), 'y': 290.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(10.0893, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(644.0893, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.3477]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(50.9616, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(437.0384, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.2096]], grad_fn=<SigmoidBackward0>), 'y': 488.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(59.3272, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(731.6728, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.4061]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(17.7320, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(836.2680, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.4758]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(67.0212, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(924.9788, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0025, 0.5349]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(132.0239, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1072.0239, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0024, 0.6330]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(167.0105, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(775.0105, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.4349]], grad_fn=<SigmoidBackward0>), 'y': 607.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(262.5015, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1122.5015, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.6666]], grad_fn=<SigmoidBackward0>), 'y': 859.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(209.8584, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1143.8584, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0023, 0.6809]], grad_fn=<SigmoidBackward0>), 'y': 933.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(155.8636, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(985.8636, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.5755]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(148.3447, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(972.3447, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0027, 0.5665]], grad_fn=<SigmoidBackward0>), 'y': 823.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(17.0164, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(600.9836, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.3189]], grad_fn=<SigmoidBackward0>), 'y': 618.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(16.0399, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(523.9601, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.2676]], grad_fn=<SigmoidBackward0>), 'y': 540.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(48.0364, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(789.9636, grad_fn=<AddBackward0>), 'output':
tensor([[0.0012, 0.0023, 0.4449]], grad_fn=<SigmoidBackward0>), 'y': 838.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(9.3060, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(258.3060, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.0905]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(90.2196, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(448.7804, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.2175]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(58.7470, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(207.7470, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.0567]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(66.0556, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(491.9444, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.2462]], grad_fn=<SigmoidBackward0>), 'y': 558.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(86.6802, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1109.6802, grad_fn=<AddBackward0>), 'output':
tensor([[0.0011, 0.0021, 0.6581]], grad_fn=<SigmoidBackward0>), 'y': 1022.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(46.2398, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(919.7602, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0030, 0.5314]], grad_fn=<SigmoidBackward0>), 'y': 966.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(32.7290, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(359.2710, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.1578]], grad_fn=<SigmoidBackward0>), 'y': 392.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(52.3627, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(786.3627, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.4425]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(5.0188, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(545.0188, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.2816]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(42.7601, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(982.7601, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0024, 0.5735]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.6125, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(625.6125, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.3353]], grad_fn=<SigmoidBackward0>), 'y': 620.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.1357, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(614.1357, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.3277]], grad_fn=<SigmoidBackward0>), 'y': 595.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(124.7461, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(608.2539, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.3238]], grad_fn=<SigmoidBackward0>), 'y': 733.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(160.0956, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(629.9044, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.3382]], grad_fn=<SigmoidBackward0>), 'y': 790.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(205.2358, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(648.7642, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.3508]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(145.0725, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(375.9275, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.1689]], grad_fn=<SigmoidBackward0>), 'y': 521.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(194.5711, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(862.4289, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.4932]], grad_fn=<SigmoidBackward0>), 'y': 1057.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(79.6285, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(218.6285, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0029, 0.0640]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(55.1020, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(301.8980, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.1195]], grad_fn=<SigmoidBackward0>), 'y': 357.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(15.6444, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(835.3556, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0029, 0.4752]], grad_fn=<SigmoidBackward0>), 'y': 851.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.6808, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(711.3192, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0024, 0.3925]], grad_fn=<SigmoidBackward0>), 'y': 731.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(152.1127, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1079.1127, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0024, 0.6377]], grad_fn=<SigmoidBackward0>), 'y': 926.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(40.5371, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1112.5371, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.6600]], grad_fn=<SigmoidBackward0>), 'y': 1071.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(182.4834, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1162.4834, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.6933]], grad_fn=<SigmoidBackward0>), 'y': 979.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.2170, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1144.2170, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.6811]], grad_fn=<SigmoidBackward0>), 'y': 1104.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(131.8507, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1196.8507, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.7162]], grad_fn=<SigmoidBackward0>), 'y': 1064.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(168.6501, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(763.6501, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.4274]], grad_fn=<SigmoidBackward0>), 'y': 594.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(88.1812, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(773.1812, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.4337]], grad_fn=<SigmoidBackward0>), 'y': 684.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(56.0845, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(435.9155, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.2089]], grad_fn=<SigmoidBackward0>), 'y': 492.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(7.4838, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(223.5162, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.0673]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(168.5761, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(856.4239, grad_fn=<AddBackward0>), 'output':
tensor([[0.0012, 0.0023, 0.4892]], grad_fn=<SigmoidBackward0>), 'y': 1025.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(264.9966, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(652.0034, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.3529]], grad_fn=<SigmoidBackward0>), 'y': 917.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(123.8602, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(690.1398, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0025, 0.3784]], grad_fn=<SigmoidBackward0>), 'y': 814.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(53.8595, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(280.1405, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.1050]], grad_fn=<SigmoidBackward0>), 'y': 334.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(13.8411, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(269.1589, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0030, 0.0977]], grad_fn=<SigmoidBackward0>), 'y': 283.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(123.9506, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(930.0494, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0032, 0.5383]], grad_fn=<SigmoidBackward0>), 'y': 1054.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(75.8446, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(225.8446, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.0688]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(84.2643, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(757.2643, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.4231]], grad_fn=<SigmoidBackward0>), 'y': 672.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(27.5754, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1087.4246, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.6432]], grad_fn=<SigmoidBackward0>), 'y': 1115.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(104.3331, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(315.3331, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0031, 0.1285]], grad_fn=<SigmoidBackward0>), 'y': 210.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(171.7570, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(941.7570, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0029, 0.5461]], grad_fn=<SigmoidBackward0>), 'y': 769.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(99.9657, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(281.9657, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0033, 0.1062]], grad_fn=<SigmoidBackward0>), 'y': 181.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(205.9749, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1043.9749, grad_fn=<AddBackward0>), 'output':
tensor([[0.0012, 0.0023, 0.6143]], grad_fn=<SigmoidBackward0>), 'y': 837.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(52.9915, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(424.9915, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.2016]], grad_fn=<SigmoidBackward0>), 'y': 371.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(83.3936, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(517.3936, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.2632]], grad_fn=<SigmoidBackward0>), 'y': 433.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(16.4883, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1106.4883, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.6559]], grad_fn=<SigmoidBackward0>), 'y': 1089.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(9.9539, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(475.0461, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.2350]], grad_fn=<SigmoidBackward0>), 'y': 485.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(85.1160, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(379.8840, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0024, 0.1715]], grad_fn=<SigmoidBackward0>), 'y': 465.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(153.7883, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(865.2117, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0024, 0.4951]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(108.7626, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(322.2374, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.1331]], grad_fn=<SigmoidBackward0>), 'y': 431.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.1060, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(193.1060, grad_fn=<AddBackward0>), 'output':
tensor([[0.0020, 0.0034, 0.0470]], grad_fn=<SigmoidBackward0>), 'y': 174.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(77.5735, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(555.4265, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.2886]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(50.1633, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(199.1633, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.0510]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(100.0892, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(690.9108, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.3789]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(15.8284, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(264.1716, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.0944]], grad_fn=<SigmoidBackward0>), 'y': 280.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(10.5392, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(275.4608, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0030, 0.1019]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.7197, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(801.7197, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.4528]], grad_fn=<SigmoidBackward0>), 'y': 761.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(143.5487, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1001.5487, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.5860]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(113.7280, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(796.7280, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.4494]], grad_fn=<SigmoidBackward0>), 'y': 682.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(64.3139, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(714.3139, grad_fn=<AddBackward0>), 'output':
tensor([[0.0012, 0.0023, 0.3945]], grad_fn=<SigmoidBackward0>), 'y': 649.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(40.0836, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(358.9164, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.1576]], grad_fn=<SigmoidBackward0>), 'y': 399.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(8.1593, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(495.8407, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.2488]], grad_fn=<SigmoidBackward0>), 'y': 504.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(53.3335, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(545.6665, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.2820]], grad_fn=<SigmoidBackward0>), 'y': 599.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.6085, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1024.6085, grad_fn=<AddBackward0>), 'output':
tensor([[0.0011, 0.0021, 0.6014]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.9391, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(409.0609, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.1910]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(43.3085, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(918.3085, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0030, 0.5305]], grad_fn=<SigmoidBackward0>), 'y': 874.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(84.1193, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(339.8807, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.1449]], grad_fn=<SigmoidBackward0>), 'y': 424.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(141.8766, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(622.1234, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.3330]], grad_fn=<SigmoidBackward0>), 'y': 764.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(5.2280, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(225.7720, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.0688]], grad_fn=<SigmoidBackward0>), 'y': 231.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(129.4368, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(871.5632, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.4993]], grad_fn=<SigmoidBackward0>), 'y': 1001.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(71.3747, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(266.3747, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.0958]], grad_fn=<SigmoidBackward0>), 'y': 194.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(35.9659, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(667.0341, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.3630]], grad_fn=<SigmoidBackward0>), 'y': 703.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(28.2816, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(236.7184, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0032, 0.0761]], grad_fn=<SigmoidBackward0>), 'y': 265.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(6.6026, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(985.3974, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0025, 0.5752]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(152.3419, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(810.3419, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.4585]], grad_fn=<SigmoidBackward0>), 'y': 657.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(92.5248, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(379.5248, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0030, 0.1713]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(143.3578, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(549.3578, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.2845]], grad_fn=<SigmoidBackward0>), 'y': 405.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(220.4447, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1307.4447, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.7899]], grad_fn=<SigmoidBackward0>), 'y': 1086.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(85.7224, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1179.7224, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.7047]], grad_fn=<SigmoidBackward0>), 'y': 1093.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(181.9120, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(320.9120, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.1322]], grad_fn=<SigmoidBackward0>), 'y': 138.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(191.3091, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(934.3091, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0023, 0.5412]], grad_fn=<SigmoidBackward0>), 'y': 742.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(1.4492, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(377.4492, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.1699]], grad_fn=<SigmoidBackward0>), 'y': 375.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(43.7867, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(456.2133, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.2224]], grad_fn=<SigmoidBackward0>), 'y': 500.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(28.1387, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(871.8613, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.4995]], grad_fn=<SigmoidBackward0>), 'y': 900.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(12.9613, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(335.0387, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0027, 0.1416]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(103.0050, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(801.9950, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.4529]], grad_fn=<SigmoidBackward0>), 'y': 905.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(117.7130, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(825.2870, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.4685]], grad_fn=<SigmoidBackward0>), 'y': 943.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(56.5729, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(416.4271, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.1959]], grad_fn=<SigmoidBackward0>), 'y': 473.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(31.2345, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(311.2345, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.1258]], grad_fn=<SigmoidBackward0>), 'y': 279.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(10.6093, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(961.3907, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.5592]], grad_fn=<SigmoidBackward0>), 'y': 972.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(114.3059, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(506.3059, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.2558]], grad_fn=<SigmoidBackward0>), 'y': 391.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(142.5688, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(315.5688, grad_fn=<AddBackward0>), 'output':
tensor([[0.0019, 0.0031, 0.1286]], grad_fn=<SigmoidBackward0>), 'y': 172.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(129.1301, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(378.1301, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.1703]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(193.0255, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(633.0255, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.3403]], grad_fn=<SigmoidBackward0>), 'y': 439.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(119.8491, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(368.8491, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.1642]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(42.9824, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(281.9824, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.1062]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(43.7873, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(288.7873, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0030, 0.1108]], grad_fn=<SigmoidBackward0>), 'y': 244.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(64.7660, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(822.7660, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0029, 0.4668]], grad_fn=<SigmoidBackward0>), 'y': 757.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(60.9041, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(962.9041, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.5602]], grad_fn=<SigmoidBackward0>), 'y': 901.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(216.5232, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(797.4768, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0028, 0.4499]], grad_fn=<SigmoidBackward0>), 'y': 1014.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(100.5135, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(515.4865, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.2619]], grad_fn=<SigmoidBackward0>), 'y': 616.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(108.3392, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(411.6608, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.1927]], grad_fn=<SigmoidBackward0>), 'y': 520.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(101.6882, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(774.3118, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0030, 0.4345]], grad_fn=<SigmoidBackward0>), 'y': 876.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(55.5726, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(519.4274, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0029, 0.2645]], grad_fn=<SigmoidBackward0>), 'y': 575.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(165.0282, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(801.9718, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.4529]], grad_fn=<SigmoidBackward0>), 'y': 967.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.6513, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(487.3487, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.2432]], grad_fn=<SigmoidBackward0>), 'y': 524.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(104.7411, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(256.7411, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.0894]], grad_fn=<SigmoidBackward0>), 'y': 151.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(63.0771, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1024.0771, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.6010]], grad_fn=<SigmoidBackward0>), 'y': 960.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(89.1873, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1155.1873, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.6884]], grad_fn=<SigmoidBackward0>), 'y': 1065.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(146.2377, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(290.2377, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.1117]], grad_fn=<SigmoidBackward0>), 'y': 143.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(140.0996, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(836.0996, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.4757]], grad_fn=<SigmoidBackward0>), 'y': 695.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(84.6118, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(996.6118, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.5827]], grad_fn=<SigmoidBackward0>), 'y': 911.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(43.6274, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(963.6274, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.5607]], grad_fn=<SigmoidBackward0>), 'y': 919.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(30.6162, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1030.3838, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0027, 0.6052]], grad_fn=<SigmoidBackward0>), 'y': 1061.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(47.8817, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(238.1183, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0029, 0.0770]], grad_fn=<SigmoidBackward0>), 'y': 286.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(133.0775, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(806.9225, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.4562]], grad_fn=<SigmoidBackward0>), 'y': 940.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(132.3896, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(260.3896, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0028, 0.0919]], grad_fn=<SigmoidBackward0>), 'y':
127.50000000000001}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(157.3216, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(758.6784, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.4241]], grad_fn=<SigmoidBackward0>), 'y': 916.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(71.3098, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(240.6902, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0030, 0.0787]], grad_fn=<SigmoidBackward0>), 'y': 312.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.7901, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(451.2099, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0027, 0.2191]], grad_fn=<SigmoidBackward0>), 'y': 508.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(53.6078, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(456.3922, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.2225]], grad_fn=<SigmoidBackward0>), 'y': 510.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.8328, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(419.8328, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0029, 0.1982]], grad_fn=<SigmoidBackward0>), 'y': 389.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(119.2266, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(272.2266, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.0997]], grad_fn=<SigmoidBackward0>), 'y': 152.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(43.0867, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(392.0867, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.1797]], grad_fn=<SigmoidBackward0>), 'y': 348.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(59.5582, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(522.5582, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0025, 0.2667]], grad_fn=<SigmoidBackward0>), 'y': 462.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(83.6805, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(696.6805, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.3827]], grad_fn=<SigmoidBackward0>), 'y': 612.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.4361, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(771.4361, grad_fn=<AddBackward0>), 'output':
tensor([[0.0012, 0.0023, 0.4326]], grad_fn=<SigmoidBackward0>), 'y': 741.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(136.8747, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(727.1253, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0031, 0.4030]], grad_fn=<SigmoidBackward0>), 'y': 864.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.6008, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(896.3992, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.5159]], grad_fn=<SigmoidBackward0>), 'y': 897.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(139.2041, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(450.7959, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.2188]], grad_fn=<SigmoidBackward0>), 'y': 590.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(133.5376, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(895.4624, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0024, 0.5153]], grad_fn=<SigmoidBackward0>), 'y': 1029.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(265.9930, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(855.0070, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.4883]], grad_fn=<SigmoidBackward0>), 'y': 1121.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(78.1043, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(482.8957, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.2402]], grad_fn=<SigmoidBackward0>), 'y': 561.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(24.7797, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(850.7797, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0028, 0.4855]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(92.0538, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(306.0538, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0030, 0.1223]], grad_fn=<SigmoidBackward0>), 'y': 213.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(32.4663, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(530.5337, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0024, 0.2720]], grad_fn=<SigmoidBackward0>), 'y': 563.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(171.1150, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1078.1150, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.6370]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(147.4528, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1236.4528, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.7426]], grad_fn=<SigmoidBackward0>), 'y': 1088.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(65.1191, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1058.1191, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.6237]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(35.1096, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(274.1096, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.1010]], grad_fn=<SigmoidBackward0>), 'y': 238.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(50.5432, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1125.5432, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.6686]], grad_fn=<SigmoidBackward0>), 'y': 1074.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(40.5911, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(548.5911, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.2840]], grad_fn=<SigmoidBackward0>), 'y': 507.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(57.9175, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(207.9175, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.0569]], grad_fn=<SigmoidBackward0>), 'y': 149.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(9.0651, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(727.9349, grad_fn=<AddBackward0>), 'output':
tensor([[0.0012, 0.0023, 0.4036]], grad_fn=<SigmoidBackward0>), 'y': 737.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(22.0865, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(200.9135, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0027, 0.0522]], grad_fn=<SigmoidBackward0>), 'y': 223.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(166.7043, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(770.2957, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0024, 0.4318]], grad_fn=<SigmoidBackward0>), 'y': 937.5}\n",
 "torch.Size([1, 3])\n",
"{'loss': tensor(140.3782, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(688.6218, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.3774]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(68.5051, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(276.4949, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0029, 0.1026]], grad_fn=<SigmoidBackward0>), 'y': 345.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(36.9886, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(820.0114, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0027, 0.4649]], grad_fn=<SigmoidBackward0>), 'y': 857.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(4.9728, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(609.0272, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.3243]], grad_fn=<SigmoidBackward0>), 'y': 614.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(39.6324, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(288.6324, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.1107]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(17.4861, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(516.4861, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0029, 0.2626]], grad_fn=<SigmoidBackward0>), 'y': 498.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(23.3051, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(335.3051, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0030, 0.1418]], grad_fn=<SigmoidBackward0>), 'y': 311.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(74.2664, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(303.2664, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.1204]], grad_fn=<SigmoidBackward0>), 'y': 228.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(21.7213, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(420.2787, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.1985]], grad_fn=<SigmoidBackward0>), 'y': 442.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(78.9110, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(357.9110, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0026, 0.1569]], grad_fn=<SigmoidBackward0>), 'y': 278.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(77.3723, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(484.3723, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.2412]], grad_fn=<SigmoidBackward0>), 'y': 406.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(114.3059, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1134.3059, grad_fn=<AddBackward0>), 'output':
tensor([[0.0012, 0.0024, 0.6745]], grad_fn=<SigmoidBackward0>), 'y': 1019.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.0741, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(494.8849, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0029, 0.2482]], grad_fn=<SigmoidBackward0>), 'y': 494.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(42.5425, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1024.5425, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0024, 0.6013]], grad_fn=<SigmoidBackward0>), 'y': 981.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(8.6349, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(716.6349, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0024, 0.3960]], grad_fn=<SigmoidBackward0>), 'y': 707.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(3.5853, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(213.4147, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0031, 0.0605]], grad_fn=<SigmoidBackward0>), 'y': 217.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(159.7200, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(746.2800, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.4158]], grad_fn=<SigmoidBackward0>), 'y': 906.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(95.0110, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(776.9890, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.4363]], grad_fn=<SigmoidBackward0>), 'y': 872.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(195.8330, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(863.1670, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0027, 0.4937]], grad_fn=<SigmoidBackward0>), 'y': 1059.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(67.2190, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(260.7810, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.0921]], grad_fn=<SigmoidBackward0>), 'y': 328.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(103.4647, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(566.5353, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0025, 0.2960]], grad_fn=<SigmoidBackward0>), 'y': 670.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(42.9733, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(534.0267, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0029, 0.2743]], grad_fn=<SigmoidBackward0>), 'y': 577.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(6.4482, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(295.5518, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0029, 0.1153]], grad_fn=<SigmoidBackward0>), 'y': 302.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(103.5750, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(653.5750, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0024, 0.3540]], grad_fn=<SigmoidBackward0>), 'y': 549.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.8348, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(259.8348, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0029, 0.0915]], grad_fn=<SigmoidBackward0>), 'y': 258.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(102.2562, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(271.2562, grad_fn=<AddBackward0>), 'output':
tensor([[0.0018, 0.0030, 0.0991]], grad_fn=<SigmoidBackward0>), 'y': 168.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(60.6711, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(735.6711, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.4087]], grad_fn=<SigmoidBackward0>), 'y': 674.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(27.2986, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1044.2986, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0026, 0.6145]], grad_fn=<SigmoidBackward0>), 'y': 1016.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.2041, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(824.8610, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0027, 0.4682]], grad_fn=<SigmoidBackward0>), 'y': 825.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(38.1968, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(683.1968, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0024, 0.3737]], grad_fn=<SigmoidBackward0>), 'y': 644.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(116.7983, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(1138.7983, grad_fn=<AddBackward0>), 'output':
tensor([[0.0011, 0.0021, 0.6775]], grad_fn=<SigmoidBackward0>), 'y': 1021.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(56.8266, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(423.1734, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0024, 0.2004]], grad_fn=<SigmoidBackward0>), 'y': 480.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(163.3369, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(806.6631, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.4560]], grad_fn=<SigmoidBackward0>), 'y': 970.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(89.7592, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(933.2408, grad_fn=<AddBackward0>), 'output':
tensor([[0.0011, 0.0020, 0.5405]], grad_fn=<SigmoidBackward0>), 'y': 1023.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(169.7809, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(398.2191, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0028, 0.1837]], grad_fn=<SigmoidBackward0>), 'y': 568.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(96.7416, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(714.2584, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0024, 0.3945]], grad_fn=<SigmoidBackward0>), 'y': 811.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(18.1935, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(549.1935, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0027, 0.2844]], grad_fn=<SigmoidBackward0>), 'y': 530.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(52.2772, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(976.2772, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0025, 0.5691]], grad_fn=<SigmoidBackward0>), 'y': 923.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(28.5931, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(610.4069, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0024, 0.3252]], grad_fn=<SigmoidBackward0>), 'y': 639.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(1.7466, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(292.7466, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0028, 0.1134]], grad_fn=<SigmoidBackward0>), 'y': 290.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(62.9717, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(696.9717, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.3829]], grad_fn=<SigmoidBackward0>), 'y': 633.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(11.1714, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(476.8286, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.2361]], grad_fn=<SigmoidBackward0>), 'y': 488.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.0731, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(791.8824, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.4462]], grad_fn=<SigmoidBackward0>), 'y': 791.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(9.2059, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(864.2059, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.4944]], grad_fn=<SigmoidBackward0>), 'y': 854.5}\n",
"torch.Size([1, 3])\n",
 "{'loss': tensor(125.3990, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(866.6010, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.4960]], grad_fn=<SigmoidBackward0>), 'y': 992.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(10.1859, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(928.8141, grad_fn=<AddBackward0>), 'output':
tensor([[0.0013, 0.0024, 0.5375]], grad_fn=<SigmoidBackward0>), 'y': 939.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(14.2213, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(622.2213, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0027, 0.3331]], grad_fn=<SigmoidBackward0>), 'y': 607.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(98.2665, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(958.2665, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.5571]], grad_fn=<SigmoidBackward0>), 'y': 859.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(21.9672, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(955.9672, grad_fn=<AddBackward0>), 'output':
tensor([[0.0012, 0.0022, 0.5556]], grad_fn=<SigmoidBackward0>), 'y': 933.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(52.6953, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(776.3047, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.4358]], grad_fn=<SigmoidBackward0>), 'y': 829.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(19.6815, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(803.3185, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0027, 0.4538]], grad_fn=<SigmoidBackward0>), 'y': 823.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(79.6647, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(538.3353, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0026, 0.2772]], grad_fn=<SigmoidBackward0>), 'y': 618.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(17.3749, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(522.6251, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.2667]], grad_fn=<SigmoidBackward0>), 'y': 540.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(12.7915, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(851.7915, grad_fn=<AddBackward0>), 'output':
tensor([[0.0012, 0.0022, 0.4862]], grad_fn=<SigmoidBackward0>), 'y': 838.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(29.1475, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(278.1475, grad_fn=<AddBackward0>), 'output':
tensor([[0.0016, 0.0028, 0.1037]], grad_fn=<SigmoidBackward0>), 'y': 248.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(35.3149, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(503.6851, grad_fn=<AddBackward0>), 'output':
tensor([[0.0015, 0.0027, 0.2541]], grad_fn=<SigmoidBackward0>), 'y': 539.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(74.4803, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(223.4803, grad_fn=<AddBackward0>), 'output':
tensor([[0.0017, 0.0030, 0.0672]], grad_fn=<SigmoidBackward0>), 'y': 148.5}\n",
"torch.Size([1, 3])\n",
"{'loss': tensor(0.3265, grad_fn=<SmoothL1LossBackward0>),
'posin5seconds': tensor(559.3081, grad_fn=<AddBackward0>), 'output':
tensor([[0.0014, 0.0025, 0.2912]], grad_fn=<SigmoidBackward0>), 'y': 558.5}\n"
]
},
{
"output_type": "error",
 "ename": "KeyboardInterrupt",
"evalue": "",
"traceback": [
"\
u001b[0;31m------------------------------------------------------------------------
---\u001b[0m",
"\u001b[0;31mKeyboardInterrupt\u001b[0m
Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-47-ff2d8188c05e>\u001b[0m in \
u001b[0;36m<cell line: 9>\u001b[0;34m()\u001b[0m\n\u001b[1;32m 11\u001b[0m
\u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzero_grad\u001b[0m\
u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\
u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0mequis\u001b[0m\
u001b[0;34m=\u001b[0m\u001b[0mresnetimages\u001b[0m\u001b[0;34m[\u001b[0m\
u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munsqueeze\
u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\
u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m
\u001b[0moutput\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m(\
u001b[0m\u001b[0mequis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\
u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 14\u001b[0m \
u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m.\
u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\
u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m \
u001b[0moutput0angle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0moutput\u001b[0m\
u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\
u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mnp\u001b[0m\
u001b[0;34m.\u001b[0m\u001b[0mpi\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\
u001b[0m\u001b[0m\n",
"\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/
module.py\u001b[0m in \u001b[0;36m_wrapped_call_impl\u001b[0;34m(self, *args,
**kwargs)\u001b[0m\n\u001b[1;32m 1551\u001b[0m \u001b[0;32mreturn\
u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_compiled_call_impl\
u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\
u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\
u001b[0m \u001b[0;31m# type: ignore[misc]\u001b[0m\u001b[0;34m\u001b[0m\
u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1552\u001b[0m \
u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\
u001b[0m\u001b[0m\n\u001b[0;32m-> 1553\u001b[0;31m \u001b[0;32mreturn\
u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call_impl\u001b[0m\
u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\
u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\
u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1554\
u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1555\u001b[0m \
u001b[0;32mdef\u001b[0m \u001b[0m_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\
u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\
u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\
u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\
u001b[0m\u001b[0m\n",
"\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/
module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *args, **kwargs)\
u001b[0m\n\u001b[1;32m 1560\u001b[0m \u001b[0;32mor\u001b[0m \
u001b[0m_global_backward_pre_hooks\u001b[0m \u001b[0;32mor\u001b[0m \
u001b[0m_global_backward_hooks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\
u001b[0m\n\u001b[1;32m 1561\u001b[0m or _global_forward_hooks or
_global_forward_pre_hooks):\n\u001b[0;32m-> 1562\u001b[0;31m \
u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\
u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\
u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\
u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1563\u001b[0m \u001b[0;34m\
u001b[0m\u001b[0m\n\u001b[1;32m 1564\u001b[0m \u001b[0;32mtry\u001b[0m\
u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;32m<ipython-input-44-bc7df3066431>\u001b[0m in \
u001b[0;36mforward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 5\u001b[0m
\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfc\u001b[0m\u001b[0;34m=\
u001b[0m\u001b[0mnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLinear\u001b[0m\
u001b[0;34m(\u001b[0m\u001b[0;36m1000\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\
u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\
n\u001b[1;32m 6\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mforward\
u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m\
u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\
u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \
u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\
u001b[0m\u001b[0mresnet50\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\
u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\
u001b[0m\u001b[1;32m 8\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m=\
u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfc\u001b[0m\
u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\
u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \
u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\
u001b[0m\u001b[0msigmoid\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\
u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/
module.py\u001b[0m in \u001b[0;36m_wrapped_call_impl\u001b[0;34m(self, *args,
**kwargs)\u001b[0m\n\u001b[1;32m 1551\u001b[0m \u001b[0;32mreturn\
u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_compiled_call_impl\
u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\
u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\
u001b[0m \u001b[0;31m# type: ignore[misc]\u001b[0m\u001b[0;34m\u001b[0m\
u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1552\u001b[0m \
u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\
u001b[0m\u001b[0m\n\u001b[0;32m-> 1553\u001b[0;31m \u001b[0;32mreturn\
u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call_impl\u001b[0m\
u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\
u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\
u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1554\
u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1555\u001b[0m \
u001b[0;32mdef\u001b[0m \u001b[0m_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\
u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\
u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\
u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\
u001b[0m\u001b[0m\n",
"\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/
module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *args, **kwargs)\
u001b[0m\n\u001b[1;32m 1560\u001b[0m \u001b[0;32mor\u001b[0m \
u001b[0m_global_backward_pre_hooks\u001b[0m \u001b[0;32mor\u001b[0m \
u001b[0m_global_backward_hooks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\
u001b[0m\n\u001b[1;32m 1561\u001b[0m or _global_forward_hooks or
_global_forward_pre_hooks):\n\u001b[0;32m-> 1562\u001b[0;31m \
u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\
u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\
u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\
u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1563\u001b[0m \u001b[0;34m\
u001b[0m\u001b[0m\n\u001b[1;32m 1564\u001b[0m \u001b[0;32mtry\u001b[0m\
u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",