data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preparação dos dados"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cada tipo de camada utilizada pelas redes neurais demandam um tipo diferente de dados. Por exemplo, datasets muito utilizados para redes simples como o Bostom House Prices trabalham com tensores 2D, enquanto imagens coloridas são representadas utilizando tensores 3D."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Batch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O primeiro eixo(eixo 0) em todos os tensores do PyTorch representa o tensor de amostras, assim imaginando um dataset de imagens, esse eixo representa o número de imagens que serão processadas pelo modelo. Os modelos de deep learning não processam todo o dataset de uma vez, ao invés disso ele quebra esse grande dataset em pequenos conjuntos chamados de batch.\n",
    "Devido a isso o primeiro eixo é geralmente chamado de *batch axis*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Representação de dados no PyTorch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tensor 0D ou escalar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(55)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "torch.Size([])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = torch.tensor(55)\n",
    "print(x)\n",
    "x.size()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tensor 1D ou vetor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os tensores de 1 dimensão são semelhante aos vetores ou no caso do python as listas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ 4.,  6.,  8., 10.])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "torch.Size([4])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = torch.FloatTensor([4, 6, 8, 10])\n",
    "print(x)\n",
    "x.size()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tensor 2D ou matrizes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dados no formato (samples, features) são representados como matrizes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 5., 78.,  2., 34.,  0.],\n",
      "        [ 6., 79.,  3., 35.,  1.],\n",
      "        [ 7., 80.,  4., 36.,  2.]])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "torch.Size([3, 5])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = torch.FloatTensor([[5, 78, 2, 34, 0],\n",
    "                       [6, 79, 3, 35, 1],\n",
    "                       [7, 80, 4, 36, 2]])\n",
    "print(x)\n",
    "x.size()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tensor 3D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os tensores 3D são utilizados para representar dados no formato (samples, timesteps, features). Séries temporais como preço de ações por exemplo são normalmente representada por tensores 3D."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[[ 5., 78.,  2., 34.,  0.],\n",
      "         [ 6., 79.,  3., 35.,  1.],\n",
      "         [ 7., 80.,  4., 36.,  2.]],\n",
      "\n",
      "        [[ 5., 78.,  2., 34.,  0.],\n",
      "         [ 6., 79.,  3., 35.,  1.],\n",
      "         [ 7., 80.,  4., 36.,  2.]],\n",
      "\n",
      "        [[ 5., 78.,  2., 34.,  0.],\n",
      "         [ 6., 79.,  3., 35.,  1.],\n",
      "         [ 7., 80.,  4., 36.,  2.]]])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "torch.Size([3, 3, 5])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = torch.FloatTensor([[[5, 78, 2, 34, 0],\n",
    "                        [6, 79, 3, 35, 1],\n",
    "                        [7, 80, 4, 36, 2]],\n",
    "                       [[5, 78, 2, 34, 0],\n",
    "                        [6, 79, 3, 35, 1],\n",
    "                        [7, 80, 4, 36, 2]],\n",
    "                       [[5, 78, 2, 34, 0],\n",
    "                        [6, 79, 3, 35, 1],\n",
    "                        [7, 80, 4, 36, 2]]])\n",
    "print(x)\n",
    "x.size()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tensor 4D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os tensores 4D são utilizados para representar dados no formato (samples, width, height, channels) ou (samples,\n",
    "channels, width, height). Esses são os formatos utilizados para armazenar imagens, onde os canais são os 3 canais do RGB."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[[[ 5., 78.,  2., 34.,  0.],\n",
      "          [ 6., 79.,  3., 35.,  1.],\n",
      "          [ 7., 80.,  4., 36.,  2.]],\n",
      "\n",
      "         [[ 5., 78.,  2., 34.,  0.],\n",
      "          [ 6., 79.,  3., 35.,  1.],\n",
      "          [ 7., 80.,  4., 36.,  2.]],\n",
      "\n",
      "         [[ 5., 78.,  2., 34.,  0.],\n",
      "          [ 6., 79.,  3., 35.,  1.],\n",
      "          [ 7., 80.,  4., 36.,  2.]]]])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 3, 3, 5])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = torch.FloatTensor([[[[5, 78, 2, 34, 0],\n",
    "                        [6, 79, 3, 35, 1],\n",
    "                        [7, 80, 4, 36, 2]],\n",
    "                       [[5, 78, 2, 34, 0],\n",
    "                        [6, 79, 3, 35, 1],\n",
    "                        [7, 80, 4, 36, 2]],\n",
    "                       [[5, 78, 2, 34, 0],\n",
    "                        [6, 79, 3, 35, 1],\n",
    "                        [7, 80, 4, 36, 2]]]])\n",
    "print(x)\n",
    "x.size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}