{
  "id": 71735,
  "title": "New RNN architecture to try",
  "url": "/competitions/quickdraw-doodle-recognition/discussion/71735",
  "author_name": "Zineng Tang",
  "post_date": "2018-11-16T04:04:20.157000",
  "votes": 5,
  "comment_count": 8,
  "views": 0,
  "content": "<p>IndRnn\n<a href=\"https://github.com/batzner/indrnn\">https://github.com/batzner/indrnn</a></p>\n\n<p>It converges faster than lstm\nVery deep sequence could be built that could still converge fast</p>\n\n<p>Github:\n<a href=\"https://github.com/batzner/indrnn\">https://github.com/batzner/indrnn</a></p>",
  "messages": [
    {
      "id": 422317,
      "postDate": "2018-11-16T04:04:20.157Z",
      "content": "<p>IndRnn\n<a href=\"https://github.com/batzner/indrnn\">https://github.com/batzner/indrnn</a></p>\n\n<p>It converges faster than lstm\nVery deep sequence could be built that could still converge fast</p>\n\n<p>Github:\n<a href=\"https://github.com/batzner/indrnn\">https://github.com/batzner/indrnn</a></p>",
      "rawMarkdown": "IndRnn\nhttps://github.com/batzner/indrnn\n\nIt converges faster than lstm\nVery deep sequence could be built that could still converge fast\n\nGithub:\nhttps://github.com/batzner/indrnn\n",
      "votes": 5
    },
    {
      "id": 423532,
      "postDate": "2018-11-18T13:53:25.850Z",
      "content": "<p>Can someone explain why RNN makes sense for this competition? I would think that since we are looking at images, convnets would be the best approach. Is it because we have the timing/order for the strokes used to draw the images?</p>",
      "rawMarkdown": "Can someone explain why RNN makes sense for this competition? I would think that since we are looking at images, convnets would be the best approach. Is it because we have the timing/order for the strokes used to draw the images?",
      "votes": 1,
      "replies": [
        {
          "id": 423538,
          "postDate": "2018-11-18T14:00:34.010Z",
          "content": "<p>Yes, integrating timing/order might be helpful and RNNs can be useful for that.</p>",
          "rawMarkdown": "Yes, integrating timing/order might be helpful and RNNs can be useful for that.",
          "votes": 1
        },
        {
          "id": 423679,
          "postDate": "2018-11-18T21:33:03.113Z",
          "content": "<p>There are at least two way to look at this problem:\n1 - Image classification using images, where CNN is the best choice\n2- sequences of strokes, which consist of sequences of points (x, y) coordinates, where a RNN makes sense</p>",
          "rawMarkdown": "There are at least two way to look at this problem:\n1 - Image classification using images, where CNN is the best choice\n2- sequences of strokes, which consist of sequences of points (x, y) coordinates, where a RNN makes sense",
          "votes": 1
        }
      ]
    },
    {
      "id": 423511,
      "postDate": "2018-11-18T12:50:03.670Z",
      "content": "<p>In my case IndyRNNs were superior to other methods. Problem is that they take forever to train. :/ \nwish there was a CuDNN implementation that worked with ind on dynamic sequences.</p>",
      "rawMarkdown": "In my case IndyRNNs were superior to other methods. Problem is that they take forever to train. :/ \nwish there was a CuDNN implementation that worked with ind on dynamic sequences.",
      "replies": [
        {
          "id": 423524,
          "postDate": "2018-11-18T13:44:10.210Z",
          "content": "<p>there is a cuda version</p>\n\n<p><a href=\"https://github.com/Sunnydreamrain/IndRNN_pytorch\">https://github.com/Sunnydreamrain/IndRNN_pytorch</a></p>\n\n<p>cuda_IndRNN_onlyrecurrent is the CUDA version. It is much faster than the simple pytorch implementation. For the sequential MNIST example (length 784), it runs over 31 times faster.</p>",
          "rawMarkdown": "there is a cuda version\n\nhttps://github.com/Sunnydreamrain/IndRNN_pytorch\n\ncuda_IndRNN_onlyrecurrent is the CUDA version. It is much faster than the simple pytorch implementation. For the sequential MNIST example (length 784), it runs over 31 times faster."
        },
        {
          "id": 423536,
          "postDate": "2018-11-18T13:56:26.987Z",
          "content": "<p>I do my networks in Tensorflow, so I don't know how things work in Pytorch, but for tensorflow you have CUDA-LSTM  and CUDNN-LSTM and the latter is much faster. Only the former can be used in dynamic sequences :/</p>\n\n<p>IndyLSTM has only CUDA version and not CuDNN optimized version</p>",
          "rawMarkdown": "I do my networks in Tensorflow, so I don't know how things work in Pytorch, but for tensorflow you have CUDA-LSTM  and CUDNN-LSTM and the latter is much faster. Only the former can be used in dynamic sequences :/\n\nIndyLSTM has only CUDA version and not CuDNN optimized version"
        },
        {
          "id": 423550,
          "postDate": "2018-11-18T14:16:47.843Z",
          "content": "<p>one suggestion is to divide the strokes into time slot: e.g. first 0.2 sec, next 0.2 sec ...</p>\n\n<p>this will keep your seq fixed length (some padding may be required)</p>\n\n<p>another possibility is to divide by  first 20%, next 20% of total points/strokes drawn , ... etc</p>",
          "rawMarkdown": "one suggestion is to divide the strokes into time slot: e.g. first 0.2 sec, next 0.2 sec ...\n\nthis will keep your seq fixed length (some padding may be required)\n\n\nanother possibility is to divide by  first 20%, next 20% of total points/strokes drawn , ... etc",
          "votes": 2
        }
      ]
    },
    {
      "id": 423220,
      "postDate": "2018-11-17T18:11:53.390Z",
      "rawMarkdown": "",
      "votes": 2,
      "isDeleted": true
    }
  ],
  "comments": [
    {
      "id": 423532,
      "author_name": "Allen",
      "author_url": "",
      "post_date": "2018-11-18T13:53:25.850000",
      "content": "<p>Can someone explain why RNN makes sense for this competition? I would think that since we are looking at images, convnets would be the best approach. Is it because we have the timing/order for the strokes used to draw the images?</p>",
      "votes": 1,
      "replies": [
        {
          "id": 423538,
          "author_name": "Miha Skalic",
          "author_url": "",
          "post_date": "2018-11-18T14:00:34.010000",
          "content": "<p>Yes, integrating timing/order might be helpful and RNNs can be useful for that.</p>",
          "votes": 1,
          "replies": []
        },
        {
          "id": 423679,
          "author_name": "Nuno Ferreira",
          "author_url": "",
          "post_date": "2018-11-18T21:33:03.113000",
          "content": "<p>There are at least two way to look at this problem:\n1 - Image classification using images, where CNN is the best choice\n2- sequences of strokes, which consist of sequences of points (x, y) coordinates, where a RNN makes sense</p>",
          "votes": 1,
          "replies": []
        }
      ]
    },
    {
      "id": 423511,
      "author_name": "Miha Skalic",
      "author_url": "",
      "post_date": "2018-11-18T12:50:03.670000",
      "content": "<p>In my case IndyRNNs were superior to other methods. Problem is that they take forever to train. :/ \nwish there was a CuDNN implementation that worked with ind on dynamic sequences.</p>",
      "votes": 0,
      "replies": [
        {
          "id": 423524,
          "author_name": "hengck23",
          "author_url": "",
          "post_date": "2018-11-18T13:44:10.210000",
          "content": "<p>there is a cuda version</p>\n\n<p><a href=\"https://github.com/Sunnydreamrain/IndRNN_pytorch\">https://github.com/Sunnydreamrain/IndRNN_pytorch</a></p>\n\n<p>cuda_IndRNN_onlyrecurrent is the CUDA version. It is much faster than the simple pytorch implementation. For the sequential MNIST example (length 784), it runs over 31 times faster.</p>",
          "votes": 0,
          "replies": []
        },
        {
          "id": 423536,
          "author_name": "Miha Skalic",
          "author_url": "",
          "post_date": "2018-11-18T13:56:26.987000",
          "content": "<p>I do my networks in Tensorflow, so I don't know how things work in Pytorch, but for tensorflow you have CUDA-LSTM  and CUDNN-LSTM and the latter is much faster. Only the former can be used in dynamic sequences :/</p>\n\n<p>IndyLSTM has only CUDA version and not CuDNN optimized version</p>",
          "votes": 0,
          "replies": []
        },
        {
          "id": 423550,
          "author_name": "hengck23",
          "author_url": "",
          "post_date": "2018-11-18T14:16:47.843000",
          "content": "<p>one suggestion is to divide the strokes into time slot: e.g. first 0.2 sec, next 0.2 sec ...</p>\n\n<p>this will keep your seq fixed length (some padding may be required)</p>\n\n<p>another possibility is to divide by  first 20%, next 20% of total points/strokes drawn , ... etc</p>",
          "votes": 2,
          "replies": []
        }
      ]
    },
    {
      "id": 423220,
      "author_name": "",
      "author_url": "",
      "post_date": "2018-11-17T18:11:53.390000",
      "content": "",
      "votes": 2,
      "replies": []
    }
  ],
  "raw_markdown_by_id": {
    "422317": "IndRnn\nhttps://github.com/batzner/indrnn\n\nIt converges faster than lstm\nVery deep sequence could be built that could still converge fast\n\nGithub:\nhttps://github.com/batzner/indrnn\n",
    "423532": "Can someone explain why RNN makes sense for this competition? I would think that since we are looking at images, convnets would be the best approach. Is it because we have the timing/order for the strokes used to draw the images?",
    "423511": "In my case IndyRNNs were superior to other methods. Problem is that they take forever to train. :/ \nwish there was a CuDNN implementation that worked with ind on dynamic sequences.",
    "423220": ""
  }
}