{
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"name": "tensorflow_programming_concepts.ipynb",
"version": "0.3.2",
"views": {},
"default_view": {},
"collapsed_sections": [
"JndnmDMp66FL",
"Zep4W80H9awM"
]
}
},
"cells": [
{
      "metadata": {
        "id": "JndnmDMp66FL",
        "colab_type": "text"
      },
      "source": [
        "#### Copyright 2017 Google LLC."
      ],
      "cell_type": "markdown"
    },
    {
      "metadata": {
        "id": "hMqWDc_m6rUC",
        "colab_type": "code",
        "colab": {
          "autoexec": {
            "startup": false,
            "wait_interval": 0
          }
        },
        "cellView": "both"
      },
      "source": [
        "# Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "# https://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License."
      ],
      "cell_type": "code",
      "execution_count": 0,
      "outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "rFpcvnCJ4Xkf",
"colab_type": "text"
},
"source": [
" # Conceptos de programación de TensorFlow"]},
{
"cell_type": "markdown",
"metadata": {
"id": "9IkBOsrNzahz",
"colab_type": "text"
},
"source": [
" **Objetivos de aprendizaje:**\n",
"  * Obtén información sobre los conceptos básicos del modelo de programación de TensorFlow, enfocado en los siguientes conceptos:\n",
"    * tensores\n",
"    * operaciones\n",
"    * gráficos\n",
"    * sesiones\n",
"  * Crea un programa simple de TensorFlow que genere un gráfico predeterminado y una sesión que ejecute el gráfico."]},
{
"cell_type": "markdown",
"metadata": {
"id": "YMG9mHPdzahz",
"colab_type": "text"
},
"source": [
" **Nota:** Lee atentamente este instructivo. El modelo de programación de TensorFlow probablemente sea diferente a otros que conozcas y, por lo tanto, tal vez no sea lo suficientemente intuitivo."]},
{
"cell_type": "markdown",
"metadata": {
"id": "NzKsjX-ufyVY",
"colab_type": "text"
},
"source": [
" ## Resumen de conceptos\n",
"El nombre de TensorFlow proviene de **tensores**, que son matrices de dimensionalidad arbitraria. Con TensorFlow, puedes manipular tensores con una gran cantidad de dimensiones. No obstante, mayormente trabajarás con uno o más de los siguientes tensores de baja dimensionalidad:\n",
"  * Un **escalar** es una matriz de 0-d (un tensor en el orden 0). Por ejemplo, `\"Howdy\"` o `5`\n",
"  * Un **vector** es una matriz de 1-d (un tensor en el orden 1). Por ejemplo, `[2, 3, 5, 7, 11]` o `[5]`\n",
"  * Un **arreglo** es una matriz de 2-d (un tensor en el orden 2). Por ejemplo, `[[3.1, 8.2, 5.9][4.3, -2.7, 6.5]]`\n\n",
"Las **operaciones** de TensorFlow crean, destruyen y manipulan tensores. La mayoría de las líneas de código en un programa típico de TensorFlow son operaciones.\n\n",
"Un **gráfico** de TensorFlow (también conocido como **gráfico computacional** o **gráfico de flujo de datos**) es, de hecho, una estructura de datos de gráfico. Muchos programas de TensorFlow consisten en un solo gráfico, pero es posible que los programas de TensorFlow alternativamente creen gráficos múltiples. Los nodos de un gráfico son operaciones; los bordes de un gráfico son tensores. Los tensores fluyen en el gráfico, manipulado en cada nodo mediante una operación. El tensor de resultado de una operación por lo general se convierte en el tensor de entrada de una operación subsiguiente. TensorFlow implementa un **modelo de ejecución relajado**, lo que significa que los nodos solo se calculan cuando es necesario, en función de los nodos asociados.\n\n",
"Los tensores pueden almacenarse en el gráfico como **constantes** o **variables**. Como podrás imaginar, las constantes tienen tensores cuyos valores no pueden cambiar, mientras que las variables tienen tensores cuyos valores sí pueden cambiar. Sin embargo, lo que posiblemente no imagines es que las constantes y las variables son solo más operaciones en el gráfico. Una constante es una operación que siempre arroja el mismo valor de tensor. Una variable es una operación que arrojará el tensor que tuviera asignado.\n\n",
"Para definir una constante, usa el operador `tf.constant` y envía su valor. Por ejemplo:\n",
"```\n",
"  x = tf.constant([5.2])\n",
"```\n",
"De manera similar, puedes crear una variable como la siguiente:\n",
"```\n",
"  y = tf.Variable([5])\n",
"```\n",
"O bien puedes crear primero la variable y, luego, asignar un valor como el siguiente (ten en cuenta que siempre debes especificar un valor predeterminado):\n",
"```\n",
"  y = tf.Variable([0])\n",
"  y = y.assign([5])\n",
"```\n",
"Una vez que hayas definido algunas constantes o variables, podrás combinarlas con otras operaciones, como `tf.add`. Cuando evalúas la operación `tf.add`, esta invocará a tus operaciones `tf.constant` o `tf.Variable` para obtener sus valores y, luego, obtener un tensor nuevo con la suma de esos valores.\n\n",
"Los gráficos deben ejecutarse dentro de una **sesión** de TensorFlow, que incluye el estado de los gráficos que ejecuta:\n",
"```\n",
"with tf.Session() as sess:\n",
"  initialization = tf.global_variables_initializer()\n",
"  print y.eval()\n",
"```\n",
"Cuando trabajas con variables `tf.Variable`, debes inicializarlas de forma explícita. Para hacerlo, debes invocar a `tf.global_variables_initializer` al inicio de la sesión, como se muestra arriba.\n\n",
"**Nota:** Una sesión puede distribuir la ejecución del gráfico en varias máquinas (si asumimos que el programa se ejecuta en un marco de trabajo de cálculo distribuido). Para obtener más información, consulta [TensorFlow distribuido](https://www.tensorflow.org/deploy/distributed).\n",
"### Resumen\n",
"La programación de TensorFlow básicamente es un proceso de dos pasos:\n",
"1. Crea constantes, variables y operaciones en un gráfico.\n",
"2. Evalúa esas constantes, variables y operaciones en una sesión.\n",
""]},
{
"cell_type": "markdown",
"metadata": {
"id": "VL0yWNNdgBpG",
"colab_type": "text"
},
"source": [
" ## Creación de un programa simple de TensorFlow\n",
"\n",
"Veamos cómo codificar un programa simple de TensorFlow que agrega dos constantes. "]},
{
"cell_type": "markdown",
"metadata": {
"id": "mN4R0gmMzah3",
"colab_type": "text"
},
"source": [
" ### Establecimiento de sentencias de importación\n",
"\n",
"Al igual que con casi todos los programas de Python, empezarás especificando algunas sentencias de `import`.\n",
"El conjunto de sentencias de `import` necesario para ejecutar un programa de TensorFlow depende, por supuesto, de las funciones que accede tu programa. Como mínimo, debes proporcionar la sentencia `import tensorflow` en todos los programas de TensorFlow:"]},
{
"metadata": {
"id": "SDbi6heigEGA",
"colab_type": "code",
"colab": {
"autoexec": {
"startup": false,
"wait_interval": 0
}
}
},
"source": [
"import tensorflow as tf"
],
"cell_type": "code",
"execution_count": 0,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "6RRT4YIA4fQd",
"colab_type": "text"
},
"source": [
" **No te olvides de ejecutar el bloque de código previo (las sentencias de `import`).**\n",
"\n",
"Otras sentencias de importación habituales incluyen lo siguiente:\n",
"\n",
"```\n",
"  import matplotlib.pyplot as plt # Visualización del conjunto de datos\n",
"  import numpy as np              # Biblioteca de Python numérica de bajo nivel\n",
"  import pandas as pd             # Biblioteca de Python numérica de alto nivel\n",
"```"]},
{
"cell_type": "markdown",
"metadata": {
"id": "1aNpvufRgbTD",
"colab_type": "text"
},
"source": [
" TensorFlow proporciona un **gráfico predeterminado**. Sin embargo, recomendamos de forma explícita crear tu propio `Graph` en lugar de proporcionar el estado de seguimiento (p. ej., es posible que quieras trabajar con un `Graph` diferente en cada celda)."]},
{
"metadata": {
"id": "Md8ze8e9geMi",
"colab_type": "code",
"colab": {
"autoexec": {
"startup": false,
"wait_interval": 0
}
}
},
"source": [
"import tensorflow as tf\n",
"\n",
"# Create a graph.\n",
"g = tf.Graph()\n",
"\n",
"# Establish the graph as the \"default\" graph.\n",
"with g.as_default():\n",
"  # Assemble a graph consisting of the following three operations:\n",
"  #   * Two tf.constant operations to create the operands.\n",
"  #   * One tf.add operation to add the two operands.\n",
"  x = tf.constant(8, name=\"x_const\")\n",
"  y = tf.constant(5, name=\"y_const\")\n",
"  sum = tf.add(x, y, name=\"x_y_sum\")\n",
"\n",
"\n",
"  # Now create a session.\n",
"  # The session will run the default graph.\n",
"  with tf.Session() as sess:\n",
"    print sum.eval()"
],
"cell_type": "code",
"execution_count": 0,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "7mSz5GVqggZy",
"colab_type": "text"
},
"source": [
" ## Ejercicio: Introduce un tercer operando\n",
"\n",
"Revisa la lista de códigos de arriba para agregar tres números enteros, en lugar de dos:\n",
"\n",
"  1. Define una tercera constante escalar de números enteros, `z`, y asígnala a un valor de `4`.\n",
"  2. Agrega `z` a `sum` para generar una nueva suma.\n",
"  \n",
"  **Sugerencia:** Consulta los documentos de la API para [tf.add()](https://www.tensorflow.org/api_docs/python/tf/add) para obtener más información sobre su firma de función.\n",
"  \n",
"  3. Vuelve a ejecutar el bloque de código modificado. ¿El programa generó la suma total correcta?"]},
{
"cell_type": "markdown",
"metadata": {
"id": "Zep4W80H9awM",
"colab_type": "text"
},
"source": [
" ### Solución\n",
"\n",
"Haz clic a continuación para conocer la solución."]},
{
"metadata": {
"id": "4OTZPqhS9kzu",
"colab_type": "code",
"colab": {
"autoexec": {
"startup": false,
"wait_interval": 0
}
}
},
"source": [
"# Create a graph.\n",
"g = tf.Graph()\n",
"\n",
"# Establish our graph as the \"default\" graph.\n",
"with g.as_default():\n",
"  # Assemble a graph consisting of three operations. \n",
"  # (Creating a tensor is an operation.)\n",
"  x = tf.constant(8, name=\"x_const\")\n",
"  y = tf.constant(5, name=\"y_const\")\n",
"  sum = tf.add(x, y, name=\"x_y_sum\")\n",
"  \n",
"  # Task 1: Define a third scalar integer constant z.\n",
"  z = tf.constant(4, name=\"z_const\")\n",
"  # Task 2: Add z to `sum` to yield a new sum.\n",
"  new_sum = tf.add(sum, z, name=\"x_y_z_sum\")\n",
"\n",
"  # Now create a session.\n",
"  # The session will run the default graph.\n",
"  with tf.Session() as sess:\n",
"    # Task 3: Ensure the program yields the correct grand total.\n",
"    print new_sum.eval()"
],
"cell_type": "code",
"execution_count": 0,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "BrlnLTesgywL",
"colab_type": "text"
},
"source": [
" ## Más información\n",
"\n",
"Para explorar más los gráficos básicos de TensorFlow, prueba con el siguiente instructivo:\n",
"\n",
"  * [Mandelbrot set](https://www.tensorflow.org/tutorials/mandelbrot#mandelbrot-set)"]}
]
}