{"id":4069,"date":"2019-11-22T11:46:07","date_gmt":"2019-11-22T11:46:07","guid":{"rendered":"https:\/\/www.tcit.cl\/2019\/11\/22\/google-quantum-copy\/"},"modified":"2023-04-26T15:30:59","modified_gmt":"2023-04-26T19:30:59","slug":"desarrolladores-front-end-tensorflowjs","status":"publish","type":"post","link":"https:\/\/www.tcit.cl\/ingles\/desarrolladores-front-end-tensorflowjs\/","title":{"rendered":"Aprendizaje autom\u00e1tico para desarrolladores front-end con Tensorflow.js"},"content":{"rendered":"

Aprendizaje autom\u00e1tico para desarrolladores front-end con Tensorflow.js<\/span><\/h1>\n

El aprendizaje autom\u00e1tico a menudo parece pertenecer al \u00e1mbito de los cient\u00edficos de datos y los desarrolladores de Python.\u00a0<\/span>Sin embargo, en los \u00faltimos a\u00f1os, se han creado marcos de c\u00f3digo abierto para que sea m\u00e1s accesible en diferentes lenguajes de programaci\u00f3n, incluido JavaScript.\u00a0<\/span>En este art\u00edculo, utilizaremos Tensorflow.js para explorar las diferentes posibilidades de usar el aprendizaje autom\u00e1tico en el navegador a trav\u00e9s de algunos proyectos de ejemplo.<\/p>\n

\u00bfQu\u00e9 es el aprendizaje autom\u00e1tico?<\/h3>\n

Antes de comenzar a sumergirnos en alg\u00fan c\u00f3digo, hablemos brevemente sobre qu\u00e9 es el aprendizaje autom\u00e1tico, as\u00ed como algunos conceptos b\u00e1sicos y terminolog\u00eda.<\/p>\n

DEFINICI\u00d3N<\/h3>\n

Una definici\u00f3n com\u00fan es que las computadoras pueden aprender de los datos sin ser programados expl\u00edcitamente.<\/p>\n

Si lo comparamos con la programaci\u00f3n tradicional, significa que permitimos que las computadoras identifiquen patrones en los datos y generen predicciones sin que tengamos que decirle exactamente qu\u00e9 buscar.<\/p>\n

Tomemos el ejemplo de detecci\u00f3n de fraude.\u00a0No hay criterios establecidos para saber qu\u00e9 hace que una transacci\u00f3n sea fraudulenta o no;\u00a0Los fraudes se pueden ejecutar en cualquier pa\u00eds, en cualquier cuenta, dirigidos a cualquier cliente, en cualquier momento, etc.\u00a0Ser\u00eda pr\u00e1cticamente imposible rastrear todo esto manualmente.<\/p>\n

Sin embargo, utilizando datos previos sobre gastos fraudulentos reunidos a lo largo de los a\u00f1os, podemos entrenar un algoritmo de aprendizaje autom\u00e1tico para comprender los patrones en estos datos para generar un modelo que pueda recibir cualquier nueva transacci\u00f3n y predecir la probabilidad de fraude o no, sin dici\u00e9ndole exactamente qu\u00e9 buscar.<\/p>\n

CONCEPTOS B\u00c1SICOS<\/h3>\n

Para comprender los siguientes ejemplos de c\u00f3digo, primero debemos cubrir algunos t\u00e9rminos comunes.<\/p>\n

Modelo<\/h5>\n

Cuando entrena un algoritmo de aprendizaje autom\u00e1tico con un conjunto de datos, el modelo es el resultado de este proceso de entrenamiento.\u00a0Es un poco como una funci\u00f3n que toma datos nuevos como entrada y produce una predicci\u00f3n como salida.<\/p>\n

Etiquetas y caracter\u00edsticas<\/h5>\n

Las etiquetas y las caracter\u00edsticas se relacionan con los datos que alimenta un algoritmo en el proceso de capacitaci\u00f3n.<\/p>\n

Una etiqueta representa c\u00f3mo clasificar\u00eda cada entrada en su conjunto de datos y c\u00f3mo la etiquetar\u00eda.\u00a0Por ejemplo, si nuestro conjunto de datos era un archivo CSV que describe diferentes animales, nuestras etiquetas podr\u00edan ser palabras como \u00abgato\u00bb, \u00abperro\u00bb o \u00abserpiente\u00bb (dependiendo de lo que represente cada animal).<\/p>\n

Las caracter\u00edsticas, por otro lado, son las caracter\u00edsticas de cada entrada en su conjunto de datos.\u00a0Para nuestro ejemplo de animales, podr\u00edan ser cosas como \u00abbigotes, maullidos\u00bb, \u00abjuguetones, ladridos\u00bb, \u00abreptiles, rampantes\u00bb, etc.<\/p>\n

Con esto, un algoritmo de aprendizaje autom\u00e1tico podr\u00e1 encontrar alguna correlaci\u00f3n entre las caracter\u00edsticas y su etiqueta que utilizar\u00e1 para futuras predicciones.<\/p>\n

Redes neuronales<\/h5>\n

Las redes neuronales son un conjunto de algoritmos de aprendizaje autom\u00e1tico que intentan imitar la forma en que funciona el cerebro utilizando capas de neuronas artificiales.<\/p>\n

Ahora que hemos definido algunos t\u00e9rminos com\u00fanmente utilizados en el aprendizaje autom\u00e1tico, hablemos de lo que se puede hacer usando JavaScript y el marco Tensorflow.js.<\/span><\/p>\n

CARACTERISTICAS<\/h3>\n

Actualmente hay tres funciones disponibles:<\/p>\n

    \n
  1. Usando un modelo pre-entrenado\u00a0,<\/li>\n
  2. Transferencia de aprendizaje\u00a0,<\/li>\n
  3. Definir, ejecutar y usar su propio modelo\u00a0.<\/li>\n<\/ol>\n

    Comencemos con el m\u00e1s simple.<\/p>\n

    1. Usando un modelo pre-entrenado<\/h5>\n

    Dependiendo del problema que est\u00e9 tratando de resolver, puede haber un modelo ya capacitado con un conjunto de datos espec\u00edfico y para un prop\u00f3sito espec\u00edfico que puede aprovechar e importar en su c\u00f3digo.<\/p>\n

    Por ejemplo, supongamos que estamos construyendo un sitio web para predecir si una imagen es la imagen de un gato.\u00a0Un modelo popular de clasificaci\u00f3n de im\u00e1genes se llama\u00a0MobileNet<\/em>\u00a0y est\u00e1 disponible como modelo pre-entrenado con Tensorflow.js.<\/p>\n

    El c\u00f3digo para esto se ver\u00eda as\u00ed:<\/span><\/p>\n

    \n

    <html lang=\u00bben\u00bb><\/strong>
    \n<head><\/strong>
    \n<meta charset=\u00bbUTF-8″><\/strong>
    \n<meta name=\u00bbviewport\u00bb content=\u00bbwidth=device-width, initial-scale=1.0″><\/strong>
    \n<meta http-equiv=\u00bbX-UA-Compatible\u00bb content=\u00bbie=edge\u00bb><\/strong>
    \n<title>Cat detection<\/title><\/strong>
    \n<script src=\u00bbhttps:\/\/cdn.jsdelivr.net\/npm\/@tensorflow\/tfjs@1.0.1″> <\/script><\/strong>
    \n<script src=\u00bbhttps:\/\/cdn.jsdelivr.net\/npm\/@tensorflow-models\/mobilenet@1.0.0″> <\/script><\/strong>
    \n<\/head><\/strong>
    \n<body><\/strong>
    \n<img id=\u00bbimage\u00bb alt=\u00bbcat laying down\u00bb src=\u00bbcat.jpeg\u00bb\/><\/strong><\/p>\n

    <script><\/strong>
    \nconst img = document.getElementById(‘image’);<\/strong><\/p>\n

    const predictImage = async () => {<\/strong>
    \nconsole.log(\u00abModel loading…\u00bb);<\/strong>
    \nconst model = await mobilenet.load();<\/strong>
    \nconsole.log(\u00abModel is loaded!\u00bb)<\/strong><\/p>\n

    const predictions = await model.classify(img);<\/strong>
    \nconsole.log(‘Predictions: ‘, predictions);<\/strong>
    \n}<\/strong>
    \npredictImage();<\/strong>
    \n<\/script><\/strong>
    \n<\/body><\/strong>
    \n<\/html><\/strong><\/p>\n

    Comenzamos importando Tensorflow.js y el modelo MobileNet en la cabeza de nuestro HTML:<\/span><\/pre>\n<\/div>\n
    \n
    <script src=\u00bbhttps:\/\/cdnjs.cloudflare.com\/ajax\/libs\/tensorflow\/1.0.1\/tf.js\u00bb> <\/script><\/strong>
    \n<script src=\u00bbhttps:\/\/cdn.jsdelivr.net\/npm\/@tensorflow-models\/mobilenet@1.0.0″> <\/script><\/strong><\/p>\n
    Luego, dentro del cuerpo, tenemos un elemento de imagen que se utilizar\u00e1 para las predicciones:<\/span><\/p>\n
    <img id=\u00bbimage\u00bb alt=\u00bbcat laying down\u00bb src=\u00bbcat.jpeg\u00bb\/><\/strong><\/p>\n<\/div>\n
    Y finalmente, dentro de la\u00a0<\/span>script<\/code>etiqueta, tenemos el c\u00f3digo JavaScript que carga el modelo MobileNet pre-entrenado y clasifica la imagen encontrada en la\u00a0<\/span>image<\/code>etiqueta.\u00a0<\/span>Devuelve un conjunto de 3 predicciones ordenadas por puntuaci\u00f3n de probabilidad (el primer elemento es la mejor predicci\u00f3n).<\/p>\n
    const predictImage = async () => {<\/strong>
    \nconsole.log(\u00abModel loading…\u00bb);<\/strong>
    \nconst model = await mobilenet.load();<\/strong>
    \nconsole.log(\u00abModel is loaded!\u00bb)<\/strong>
    \nconst predictions = await model.classify(img);<\/strong>
    \nconsole.log(‘Predictions: ‘, predictions);<\/strong>
    \n}<\/strong><\/p>\n
    predictImage();<\/strong><\/p>\n
    \u00a1Y eso es!\u00a0\u00a1Esta es la forma en que puede usar un modelo previamente entrenado en el navegador con Tensorflow.js!<\/p>\n
    Algo importante que debe saber es que cargar un modelo previamente entrenado en el navegador puede llevar algo de tiempo (a veces hasta 10 segundos), por lo que probablemente desee precargar o adaptar su interfaz para que los usuarios no se vean afectados.<\/p>\n
    Si prefiere usar Tensorflow.js como m\u00f3dulo NPM, puede hacerlo importando el m\u00f3dulo de esta manera:<\/p>\n
    import * as mobilenet from ‘@tensorflow-models\/mobilenet’;<\/strong><\/p>\n
    \n
    \n
    Ahora que hemos visto c\u00f3mo usar un modelo previamente entrenado, veamos la segunda caracter\u00edstica disponible: transferencia de aprendizaje.<\/span><\/p>\n
    2. Transferencia de aprendizaje<\/span><\/h5>\n
    El aprendizaje por transferencia es la capacidad de combinar un modelo pre-entrenado con datos de entrenamiento personalizados.\u00a0Lo que esto significa es que puede aprovechar la funcionalidad de un modelo y agregar sus propias muestras sin tener que crear todo desde cero.<\/p>\n
    Por ejemplo, un algoritmo ha sido entrenado con miles de im\u00e1genes para crear un modelo de clasificaci\u00f3n de im\u00e1genes, y en lugar de crear el suyo, el aprendizaje de transferencia le permite combinar nuevas muestras de im\u00e1genes personalizadas con el modelo pre-entrenado para crear un nuevo clasificador de im\u00e1genes.\u00a0Esta caracter\u00edstica hace que sea realmente r\u00e1pido y f\u00e1cil tener un clasificador m\u00e1s personalizado.<\/p>\n
    Para proporcionar un ejemplo de c\u00f3mo se ver\u00eda esto en el c\u00f3digo, reutilicemos nuestro ejemplo anterior y modif\u00edquelo para que podamos clasificar nuevas im\u00e1genes.<\/p>\n
    Todav\u00eda tenemos que comenzar importando Tensorflow.js y MobileNet, pero esta vez tambi\u00e9n necesitamos agregar un clasificador KNN (vecino k-m\u00e1s cercano):<\/p>\n<\/div>\n
    <!– Load TensorFlow.js –><\/strong>
    \n<script src=\u00bbhttps:\/\/cdn.jsdelivr.net\/npm\/@tensorflow\/tfjs\u00bb><\/script><\/strong>
    \n<!– Load MobileNet –><\/strong>
    \n<script src=\u00bbhttps:\/\/cdn.jsdelivr.net\/npm\/@tensorflow-models\/mobilenet\u00bb><\/script><\/strong>
    \n<!– Load KNN Classifier –><\/strong>
    \n<script src=\u00bbhttps:\/\/cdn.jsdelivr.net\/npm\/@tensorflow-models\/knn-classifier\u00bb><\/script><\/strong><\/p>\n
    La raz\u00f3n por la que necesitamos un clasificador es porque (en lugar de usar solo el m\u00f3dulo MobileNet) estamos agregando muestras personalizadas que nunca antes hab\u00eda visto, por lo que el clasificador KNN nos permitir\u00e1 combinar todo y ejecutar predicciones sobre los datos combinados.<\/span><\/p>\n<\/div>\n
    Luego, podemos reemplazar la imagen del gato con una\u00a0video<\/code>etiqueta para usar im\u00e1genes de la alimentaci\u00f3n de la c\u00e1mara.<\/p>\n
    <video autoplay id=\u00bbwebcam\u00bb width=\u00bb227″ height=\u00bb227″><\/video><\/strong><\/p>\n
    Finalmente, necesitaremos agregar algunos botones en la p\u00e1gina que usaremos como etiquetas para grabar algunas muestras de video y comenzar las predicciones.<\/p>\n
    <section><\/strong>
    \n<button class=\u00bbbutton\u00bb>Left<\/button><\/strong><\/p>\n
    <button class=\u00bbbutton\u00bb>Right<\/button><\/strong><\/p>\n
    <button class=\u00bbtest-predictions\u00bb>Test<\/button><\/strong>
    \n<\/section><\/strong><\/p>\n
    Ahora, pasemos al archivo JavaScript donde comenzaremos configurando algunas variables importantes:<\/p>\n
    \/\/ Number of classes to classify<\/strong>
    \nconst NUM_CLASSES = 2;<\/strong>
    \n\/\/ Labels for our classes<\/strong>
    \nconst classes = [\u00abLeft\u00bb, \u00abRight\u00bb];<\/strong>
    \n\/\/ Webcam Image size. Must be 227.<\/strong>
    \nconst IMAGE_SIZE = 227;<\/strong>
    \n\/\/ K value for KNN<\/strong>
    \nconst TOPK = 10;<\/strong><\/p>\n
    const video = document.getElementById(\u00abwebcam\u00bb);<\/strong><\/p>\n
    En este ejemplo en particular, queremos poder clasificar la entrada de la c\u00e1mara web entre nuestra cabeza inclinada hacia la izquierda o hacia la derecha, por lo que necesitamos dos clases etiquetadas\u00a0<\/span>left<\/code>y\u00a0<\/span>right<\/code>.<\/span><\/p>\n
    El tama\u00f1o de la imagen establecido en 227 es el tama\u00f1o del elemento de video en p\u00edxeles.\u00a0Seg\u00fan los ejemplos de Tensorflow.js, este valor debe establecerse en 227 para que coincida con el formato de los datos con los que se entren\u00f3 el modelo MobileNet.\u00a0Para poder clasificar nuestros nuevos datos, este \u00faltimo debe ajustarse al mismo formato.<\/p>\n
    \n
    \n
    Luego, establecemos el valor de K en 10. El valor de K en el algoritmo KNN es importante porque representa el n\u00famero de instancias que tenemos en cuenta al determinar la clase de nuestra nueva entrada.<\/p>\n
    En este caso, el valor de 10 significa que, al predecir la etiqueta para algunos datos nuevos, miraremos a los 10 vecinos m\u00e1s cercanos a partir de los datos de entrenamiento para determinar c\u00f3mo clasificar nuestra nueva entrada.<\/p>\n
    Finalmente, estamos obteniendo el\u00a0video<\/code>elemento.\u00a0Para la l\u00f3gica, comencemos cargando el modelo y el clasificador:<\/p>\n
    async load() {<\/strong>
    \nconst knn = knnClassifier.create();<\/strong>
    \nconst mobilenetModule = await mobilenet.load();<\/strong>
    \nconsole.log(\u00abmodel loaded\u00bb);<\/strong>
    \n}<\/strong><\/p>\n
    Luego, accedamos al video:<\/span><\/p>\n
    navigator.mediaDevices<\/strong>
    \n.getUserMedia({ video: true, audio: false })<\/strong>
    \n.then(stream => {<\/strong>
    \nvideo.srcObject = stream;<\/strong>
    \nvideo.width = IMAGE_SIZE;<\/strong>
    \nvideo.height = IMAGE_SIZE;<\/strong>
    \n});<\/strong><\/div>\n
    <\/div>\n<\/div>\n<\/div>\n
    Despu\u00e9s de eso, configuremos algunos eventos de bot\u00f3n para registrar nuestros datos de muestra:<\/div>\n
    <\/div>\n
    \n
    setupButtonEvents() {<\/strong>
    \nfor (let i = 0; i < NUM_CLASSES; i++) {<\/strong>
    \nlet button = document.getElementsByClassName(\u00abbutton\u00bb)[i];<\/strong><\/p>\n
    button.onmousedown = () => {<\/strong>
    \nthis.training = i;<\/strong>
    \nthis.recordSamples = true;<\/strong>
    \n};<\/strong>
    \nbutton.onmouseup = () => (this.training = -1);<\/strong>
    \n}<\/strong>
    \n}<\/strong><\/p>\n<\/div>\n
    \n
    Escribamos nuestra funci\u00f3n que tomar\u00e1 las muestras de im\u00e1genes de la c\u00e1mara web, las formatear\u00e1 y las combinar\u00e1 con el m\u00f3dulo MobileNet:<\/span><\/p>\n
    \n
    \n
    \/\/ Get image data from video element<\/strong>
    \nconst image = tf.browser.fromPixels(video);<\/strong><\/p>\n
    let logits;<\/strong>
    \n\/\/ ‘conv_preds’ is the logits activation of MobileNet.<\/strong>
    \nconst infer = () => this.mobilenetModule.infer(image, \u00abconv_preds\u00bb);<\/strong><\/p>\n
    \/\/ Train class if one of the buttons is held down<\/strong>
    \nif (this.training != -1) {<\/strong>
    \nlogits = infer();<\/strong><\/p>\n
    \/\/ Add current image to classifier<\/strong>
    \nthis.knn.addExample(logits, this.training);<\/strong>
    \n}<\/strong><\/p>\n<\/div>\n
    Y finalmente, una vez que reunimos algunas im\u00e1genes de la c\u00e1mara web, podemos probar nuestras predicciones con el siguiente c\u00f3digo:<\/p>\n<\/div>\n
    logits = infer();<\/strong>
    \nconst res = await this.knn.predictClass(logits, TOPK);<\/strong>
    \nconst prediction = classes[res.classIndex];<\/strong><\/p>\n
    Y finalmente, puede deshacerse de los datos de la c\u00e1mara web ya que ya no los necesitamos:<\/span><\/p>\n
    \n
    \/\/ Dispose image when done<\/strong>
    \nimage.dispose();<\/strong>
    \nif (logits != null) {<\/strong>
    \nlogits.dispose();<\/strong>
    \n}<\/strong><\/div>\n<\/div>\n<\/div>\n
    <\/div>\n
    \n
    Una vez m\u00e1s, si desea ver el c\u00f3digo completo, puede encontrarlo en\u00a0<\/span>CodeSandbox<\/span>\u00a0mencionado anteriormente.<\/span><\/p>\n
    3. Entrenando a una modelo en el navegador<\/h5>\n
    La \u00faltima caracter\u00edstica es definir, entrenar y ejecutar un modelo completamente en el navegador.\u00a0Para ilustrar esto, vamos a construir el ejemplo cl\u00e1sico de reconocer Iris.<\/p>\n
    Para esto, crearemos una red neuronal que pueda clasificar los Iris en tres categor\u00edas: Setosa, Virginica y Versicolor, en base a un conjunto de datos de c\u00f3digo abierto.<\/p>\n<\/div>\n
    El n\u00facleo de cada proyecto de aprendizaje autom\u00e1tico es un conjunto de datos.\u00a0Uno de los primeros pasos que debemos emprender es dividir este conjunto de datos en un conjunto de entrenamiento y un conjunto de prueba.<\/p>\n
    La raz\u00f3n de esto es que vamos a usar nuestro conjunto de entrenamiento para entrenar nuestro algoritmo y nuestro conjunto de prueba para verificar la precisi\u00f3n de nuestras predicciones, para validar si nuestro modelo est\u00e1 listo para ser usado o necesita ser ajustado.<\/p>\n
    Nota<\/strong>\u00a0:\u00a0Para hacerlo m\u00e1s f\u00e1cil, ya divid\u00ed el conjunto de entrenamiento y el conjunto de prueba en dos archivos JSON que puede encontrar en\u00a0CodeSanbox\u00a0.<\/em><\/p>\n
    El conjunto de entrenamiento contiene 130 elementos y el conjunto de prueba 14. Si observa c\u00f3mo se ven estos datos, ver\u00e1 algo como esto:<\/p>\n
    {<\/strong>
    \n\u00absepal_length\u00bb: 5.1,<\/strong>
    \n\u00absepal_width\u00bb: 3.5,<\/strong>
    \n\u00abpetal_length\u00bb: 1.4,<\/strong>
    \n\u00abpetal_width\u00bb: 0.2,<\/strong>
    \n\u00abspecies\u00bb: \u00absetosa\u00bb<\/strong>
    \n}<\/strong><\/p>\n
    Lo que podemos ver son cuatro caracter\u00edsticas diferentes para la longitud y el ancho del s\u00e9palo y el p\u00e9talo, as\u00ed como una etiqueta para la especie.<\/p>\n
    Para poder usar esto con Tensorflow.js, necesitamos dar forma a estos datos en un formato que el marco entienda, en este caso, para los datos de entrenamiento, ser\u00e1\u00a0[130, 4]<\/code>para 130 muestras con cuatro caracter\u00edsticas por iris.<\/p>\n
    import * as trainingSet from \u00abtraining.json\u00bb;<\/strong>
    \nimport * as testSet from \u00abtesting.json\u00bb;<\/strong><\/p>\n
    const trainingData = tf.tensor2d(<\/strong>
    \ntrainingSet.map(item => [<\/strong>
    \nitem.sepal_length,<\/strong>
    \nitem.sepal_width,<\/strong>
    \nitem.petal_length,<\/strong>
    \nitem.petal_width<\/strong>
    \n]),<\/strong>
    \n[130, 4]<\/strong>
    \n);<\/strong><\/p>\n
    const testData = tf.tensor2d(<\/strong>
    \ntestSet.map(item => [<\/strong>
    \nitem.sepal_length,<\/strong>
    \nitem.sepal_width,<\/strong>
    \nitem.petal_length,<\/strong>
    \nitem.petal_width<\/strong>
    \n]),<\/strong>
    \n[14, 4]<\/strong>
    \n);<\/strong><\/p>\n
    A continuaci\u00f3n, necesitamos dar forma a nuestros datos de salida tambi\u00e9n:<\/span><\/p>\n
    \n
    const output = tf.tensor2d(trainingSet.map(item => [<\/strong>
    \nitem.species === ‘setosa’ ? 1 : 0,<\/strong>
    \nitem.species === ‘virginica’ ? 1 : 0,<\/strong>
    \nitem.species === ‘versicolor’ ? 1 : 0<\/strong><\/p>\n
    ]), [130,3])<\/strong><\/p>\n<\/div>\n
    Luego, una vez que nuestros datos est\u00e9n listos, podemos pasar a crear el modelo:<\/span><\/p>\n
    \n
    const model = tf.sequential();<\/strong><\/p>\n
    model.add(tf.layers.dense(<\/strong>
    \n{<\/strong>
    \ninputShape: 4,<\/strong>
    \nactivation: ‘sigmoid’,<\/strong>
    \nunits: 10<\/strong>
    \n}<\/strong>
    \n));<\/strong><\/p>\n
    model.add(tf.layers.dense(<\/strong>
    \n{<\/strong>
    \ninputShape: 10,<\/strong>
    \nunits: 3,<\/strong>
    \nactivation: ‘softmax’<\/strong>
    \n}<\/strong>
    \n));<\/strong><\/p>\n<\/div>\n
    En el ejemplo de c\u00f3digo anterior, comenzamos instanciando un modelo secuencial, agregamos una capa de entrada y salida.<\/p>\n
    Los par\u00e1metros que puede ver utilizados dentro (\u00a0inputShape<\/code>,\u00a0activation<\/code>y\u00a0units<\/code>) est\u00e1n fuera del alcance de esta publicaci\u00f3n, ya que pueden variar seg\u00fan el modelo que est\u00e9 creando, el tipo de datos utilizados, etc.<\/p>\n
    Una vez que nuestro modelo est\u00e9 listo, podemos entrenarlo con nuestros datos:<\/p>\n
    async function train_data(){<\/strong>
    \nfor(let i=0;i<15;i++){<\/strong>
    \nconst res = await model.fit(trainingData, outputData,{epochs: 40});<\/strong>
    \n}<\/strong>
    \n}<\/strong><\/p>\n
    async function main() {<\/strong>
    \nawait train_data();<\/strong>
    \nmodel.predict(testSet).print();<\/strong>
    \n}<\/strong><\/p>\n
    Si esto funciona bien, puede comenzar a reemplazar los datos de prueba con entradas de usuario personalizadas.<\/p>\n
    Una vez que llamemos a nuestra funci\u00f3n principal, el resultado de la predicci\u00f3n se ver\u00e1 como una de estas tres opciones:<\/p>\n
    [1,0,0] \/\/ Setosa<\/strong>
    \n[0,1,0] \/\/ Virginica<\/strong>
    \n[0,0,1] \/\/ Versicolor<\/strong><\/p>\n
    La predicci\u00f3n devuelve una matriz de tres n\u00fameros que representan la probabilidad de que los datos pertenezcan a una de las tres clases.\u00a0El n\u00famero m\u00e1s cercano a 1 es la predicci\u00f3n m\u00e1s alta.<\/p>\n
    Por ejemplo, si el resultado de la clasificaci\u00f3n es\u00a0[0.0002, 0.9494, 0.0503]<\/code>, el segundo elemento de la matriz es el m\u00e1s alto, por lo que el modelo predijo que la nueva entrada probablemente sea Virginica.<\/p>\n
    \u00a1Y eso es todo para una red neuronal simple en Tensorflow.js!<\/p>\n
    Solo hablamos de un peque\u00f1o conjunto de datos de Iris, pero si desea pasar a conjuntos de datos m\u00e1s grandes o trabajar con im\u00e1genes, los pasos ser\u00e1n los mismos:<\/p>\n
      \n
    • Recolectando los datos;<\/li>\n
    • Divisi\u00f3n entre entrenamiento y conjunto de pruebas;<\/li>\n
    • Reformatear los datos para que Tensorflow.js pueda entenderlos;<\/li>\n
    • Escogiendo tu algoritmo;<\/li>\n
    • Ajuste de los datos;<\/li>\n
    • Predecir<\/li>\n<\/ul>\n
      Si desea guardar el modelo creado para poder cargarlo en otra aplicaci\u00f3n y predecir nuevos datos, puede hacerlo con la siguiente l\u00ednea:<\/p>\n
      await model.save(‘file:\/\/\/path\/to\/my-model’); \/\/ in Node.js<\/strong><\/p>\n
      L\u00cdMITES<\/h4>\n
      \u00a1Eso es!\u00a0\u00a1Acabamos de cubrir las tres caracter\u00edsticas principales disponibles actualmente con Tensorflow.js!<\/p>\n
      Antes de terminar, creo que es importante mencionar brevemente algunos de los l\u00edmites del uso del aprendizaje autom\u00e1tico en la interfaz.<\/p>\n
      1. Rendimiento<\/h5>\n
      Importar un modelo previamente entrenado desde una fuente externa puede tener un impacto en el rendimiento de su aplicaci\u00f3n.\u00a0Algunos modelos de detecci\u00f3n de objetos, por ejemplo, tienen m\u00e1s de 10 MB, lo que ralentizar\u00e1 significativamente su sitio web.\u00a0Aseg\u00farese de pensar en su experiencia de usuario y optimice la carga de sus activos para mejorar su rendimiento percibido.<\/p>\n
      2. Calidad de los datos de entrada<\/h5>\n
      Si crea un modelo desde cero, tendr\u00e1 que recopilar sus propios datos o buscar alg\u00fan conjunto de datos de c\u00f3digo abierto.<\/p>\n
      Antes de realizar cualquier tipo de procesamiento de datos o probar diferentes algoritmos, aseg\u00farese de verificar la calidad de sus datos de entrada.\u00a0Por ejemplo, si est\u00e1 tratando de construir un modelo de an\u00e1lisis de sentimientos para reconocer las emociones en fragmentos de texto, aseg\u00farese de que los datos que est\u00e1 utilizando para entrenar su modelo sean precisos y diversos.\u00a0Si la calidad de los datos utilizados es baja, el resultado de su entrenamiento ser\u00e1 in\u00fatil.<\/p>\n
      3. Responsabilidad<\/h5>\n
      El uso de un modelo pre-entrenado de c\u00f3digo abierto puede ser muy r\u00e1pido y sin esfuerzo.\u00a0Sin embargo, tambi\u00e9n significa que no siempre sabe c\u00f3mo se gener\u00f3, de qu\u00e9 estaba hecho el conjunto de datos o incluso qu\u00e9 algoritmo se utiliz\u00f3.\u00a0Algunos modelos se llaman \u00abcajas negras\u00bb, lo que significa que realmente no se sabe c\u00f3mo predijeron un determinado resultado.<\/p>\n
      Dependiendo de lo que intente construir, esto puede ser un problema.\u00a0Por ejemplo, si est\u00e1 utilizando un modelo de aprendizaje autom\u00e1tico para ayudar a detectar la probabilidad de que alguien tenga c\u00e1ncer en base a im\u00e1genes escaneadas, en caso de falso negativo (el modelo predijo que una persona no ten\u00eda c\u00e1ncer cuando realmente lo ten\u00eda), hay podr\u00eda ser una responsabilidad legal real y tendr\u00eda que ser capaz de explicar por qu\u00e9 el modelo hizo una cierta predicci\u00f3n.<\/p>\n
      Resumen<\/h3>\n
      En conclusi\u00f3n, usar JavaScript y marcos como Tensorflow.js es una excelente manera de comenzar y aprender m\u00e1s sobre el aprendizaje autom\u00e1tico.\u00a0A pesar de que una aplicaci\u00f3n lista para producci\u00f3n probablemente deber\u00eda estar construida en un lenguaje como Python, JavaScript hace que sea realmente accesible para que los desarrolladores jueguen con las diferentes caracter\u00edsticas y comprendan mejor los conceptos fundamentales antes de continuar e invertir tiempo en aprender otro idioma.<\/span><\/p>\n
      En este tutorial, solo hemos cubierto lo que era posible usando Tensorflow.js, sin embargo, el ecosistema de otras bibliotecas y herramientas est\u00e1 creciendo.\u00a0Marcos m\u00e1s espec\u00edficos tambi\u00e9n est\u00e1n disponibles, lo que permite explorar el uso de la m\u00e1quina de aprendizaje con otros \u00e1mbitos como la m\u00fasica con\u00a0Magenta.js\u00a0, o la predicci\u00f3n de la navegaci\u00f3n del usuario en un sitio web utilizando\u00a0guess.js\u00a0!<\/p>\n
      A medida que las herramientas se vuelven m\u00e1s eficaces, es probable que las posibilidades de crear aplicaciones habilitadas para el aprendizaje autom\u00e1tico en JavaScript sean cada vez m\u00e1s emocionantes, y ahora es un buen momento para aprender m\u00e1s sobre ello, ya que la comunidad est\u00e1 haciendo un esfuerzo para hacerlo accesible.<\/p>\n<\/div><\/div><\/div><\/div><\/div>\n","protected":false},"excerpt":{"rendered":"","protected":false},"author":9,"featured_media":4078,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"content-type":"","footnotes":""},"categories":[32],"tags":[],"class_list":["post-4069","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-blog"],"yoast_head":"\nAprendizaje autom\u00e1tico para desarrolladores front-end con Tensorflow.js - TCIT<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.tcit.cl\/ingles\/desarrolladores-front-end-tensorflowjs\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Aprendizaje autom\u00e1tico para desarrolladores front-end con Tensorflow.js\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.tcit.cl\/ingles\/desarrolladores-front-end-tensorflowjs\/\" \/>\n<meta property=\"og:site_name\" content=\"TCIT\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/web.facebook.com\/tcitcloudsolutions\/\" \/>\n<meta property=\"article:published_time\" content=\"2019-11-22T11:46:07+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-04-26T19:30:59+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.tcit.cl\/wp-content\/uploads\/2019\/11\/17-SPAS.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1100\" \/>\n\t<meta property=\"og:image:height\" content=\"750\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Gonzalo Burgos\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Gonzalo Burgos\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"20 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/www.tcit.cl\\\/desarrolladores-front-end-tensorflowjs\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.tcit.cl\\\/desarrolladores-front-end-tensorflowjs\\\/\"},\"author\":{\"name\":\"Gonzalo Burgos\",\"@id\":\"https:\\\/\\\/www.tcit.cl\\\/#\\\/schema\\\/person\\\/3feac3eca66491ec20151f9127ed7ea1\"},\"headline\":\"Aprendizaje autom\u00e1tico para desarrolladores front-end con Tensorflow.js\",\"datePublished\":\"2019-11-22T11:46:07+00:00\",\"dateModified\":\"2023-04-26T19:30:59+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.tcit.cl\\\/desarrolladores-front-end-tensorflowjs\\\/\"},\"wordCount\":3660,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/www.tcit.cl\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/www.tcit.cl\\\/desarrolladores-front-end-tensorflowjs\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.tcit.cl\\\/wp-content\\\/uploads\\\/2019\\\/11\\\/17-SPAS.jpg\",\"articleSection\":[\"Blog\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.tcit.cl\\\/desarrolladores-front-end-tensorflowjs\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.tcit.cl\\\/desarrolladores-front-end-tensorflowjs\\\/\",\"url\":\"https:\\\/\\\/www.tcit.cl\\\/desarrolladores-front-end-tensorflowjs\\\/\",\"name\":\"Aprendizaje autom\u00e1tico para desarrolladores front-end con Tensorflow.js - TCIT\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.tcit.cl\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/www.tcit.cl\\\/desarrolladores-front-end-tensorflowjs\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/www.tcit.cl\\\/desarrolladores-front-end-tensorflowjs\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.tcit.cl\\\/wp-content\\\/uploads\\\/2019\\\/11\\\/17-SPAS.jpg\",\"datePublished\":\"2019-11-22T11:46:07+00:00\",\"dateModified\":\"2023-04-26T19:30:59+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.tcit.cl\\\/desarrolladores-front-end-tensorflowjs\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.tcit.cl\\\/desarrolladores-front-end-tensorflowjs\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.tcit.cl\\\/desarrolladores-front-end-tensorflowjs\\\/#primaryimage\",\"url\":\"https:\\\/\\\/www.tcit.cl\\\/wp-content\\\/uploads\\\/2019\\\/11\\\/17-SPAS.jpg\",\"contentUrl\":\"https:\\\/\\\/www.tcit.cl\\\/wp-content\\\/uploads\\\/2019\\\/11\\\/17-SPAS.jpg\",\"width\":1100,\"height\":750},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.tcit.cl\\\/desarrolladores-front-end-tensorflowjs\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Portada\",\"item\":\"https:\\\/\\\/www.tcit.cl\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Aprendizaje autom\u00e1tico para desarrolladores front-end con Tensorflow.js\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.tcit.cl\\\/#website\",\"url\":\"https:\\\/\\\/www.tcit.cl\\\/\",\"name\":\"https:\\\/\\\/www.tcit.cl\\\/\",\"description\":\"AI Solutions\",\"publisher\":{\"@id\":\"https:\\\/\\\/www.tcit.cl\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.tcit.cl\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/www.tcit.cl\\\/#organization\",\"name\":\"TCIT EIRL\",\"alternateName\":\"TCIT AI Solutions\",\"url\":\"https:\\\/\\\/www.tcit.cl\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.tcit.cl\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/www.tcit.cl\\\/wp-content\\\/uploads\\\/2025\\\/09\\\/cropped-TCIT_isotipo-color.png\",\"contentUrl\":\"https:\\\/\\\/www.tcit.cl\\\/wp-content\\\/uploads\\\/2025\\\/09\\\/cropped-TCIT_isotipo-color.png\",\"width\":512,\"height\":512,\"caption\":\"TCIT EIRL\"},\"image\":{\"@id\":\"https:\\\/\\\/www.tcit.cl\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/web.facebook.com\\\/tcitcloudsolutions\\\/\",\"https:\\\/\\\/www.instagram.com\\\/tcitcloudsolutions\\\/\",\"https:\\\/\\\/www.linkedin.com\\\/company\\\/tcit-cloud-solutions\\\/\"]},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.tcit.cl\\\/#\\\/schema\\\/person\\\/3feac3eca66491ec20151f9127ed7ea1\",\"name\":\"Gonzalo Burgos\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/e2d4d08554b58b6bdc8ddfc801c6b583fb9207e71f73b8a119ced6a71fc814d0?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/e2d4d08554b58b6bdc8ddfc801c6b583fb9207e71f73b8a119ced6a71fc814d0?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/e2d4d08554b58b6bdc8ddfc801c6b583fb9207e71f73b8a119ced6a71fc814d0?s=96&d=mm&r=g\",\"caption\":\"Gonzalo Burgos\"},\"url\":\"https:\\\/\\\/www.tcit.cl\\\/ingles\\\/author\\\/eduardo-albornoz-2\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Aprendizaje autom\u00e1tico para desarrolladores front-end con Tensorflow.js - TCIT","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.tcit.cl\/ingles\/desarrolladores-front-end-tensorflowjs\/","og_locale":"en_US","og_type":"article","og_title":"Aprendizaje autom\u00e1tico para desarrolladores front-end con Tensorflow.js","og_url":"https:\/\/www.tcit.cl\/ingles\/desarrolladores-front-end-tensorflowjs\/","og_site_name":"TCIT","article_publisher":"https:\/\/web.facebook.com\/tcitcloudsolutions\/","article_published_time":"2019-11-22T11:46:07+00:00","article_modified_time":"2023-04-26T19:30:59+00:00","og_image":[{"width":1100,"height":750,"url":"https:\/\/www.tcit.cl\/wp-content\/uploads\/2019\/11\/17-SPAS.jpg","type":"image\/jpeg"}],"author":"Gonzalo Burgos","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Gonzalo Burgos","Est. reading time":"20 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.tcit.cl\/desarrolladores-front-end-tensorflowjs\/#article","isPartOf":{"@id":"https:\/\/www.tcit.cl\/desarrolladores-front-end-tensorflowjs\/"},"author":{"name":"Gonzalo Burgos","@id":"https:\/\/www.tcit.cl\/#\/schema\/person\/3feac3eca66491ec20151f9127ed7ea1"},"headline":"Aprendizaje autom\u00e1tico para desarrolladores front-end con Tensorflow.js","datePublished":"2019-11-22T11:46:07+00:00","dateModified":"2023-04-26T19:30:59+00:00","mainEntityOfPage":{"@id":"https:\/\/www.tcit.cl\/desarrolladores-front-end-tensorflowjs\/"},"wordCount":3660,"commentCount":0,"publisher":{"@id":"https:\/\/www.tcit.cl\/#organization"},"image":{"@id":"https:\/\/www.tcit.cl\/desarrolladores-front-end-tensorflowjs\/#primaryimage"},"thumbnailUrl":"https:\/\/www.tcit.cl\/wp-content\/uploads\/2019\/11\/17-SPAS.jpg","articleSection":["Blog"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.tcit.cl\/desarrolladores-front-end-tensorflowjs\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.tcit.cl\/desarrolladores-front-end-tensorflowjs\/","url":"https:\/\/www.tcit.cl\/desarrolladores-front-end-tensorflowjs\/","name":"Aprendizaje autom\u00e1tico para desarrolladores front-end con Tensorflow.js - TCIT","isPartOf":{"@id":"https:\/\/www.tcit.cl\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.tcit.cl\/desarrolladores-front-end-tensorflowjs\/#primaryimage"},"image":{"@id":"https:\/\/www.tcit.cl\/desarrolladores-front-end-tensorflowjs\/#primaryimage"},"thumbnailUrl":"https:\/\/www.tcit.cl\/wp-content\/uploads\/2019\/11\/17-SPAS.jpg","datePublished":"2019-11-22T11:46:07+00:00","dateModified":"2023-04-26T19:30:59+00:00","breadcrumb":{"@id":"https:\/\/www.tcit.cl\/desarrolladores-front-end-tensorflowjs\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.tcit.cl\/desarrolladores-front-end-tensorflowjs\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.tcit.cl\/desarrolladores-front-end-tensorflowjs\/#primaryimage","url":"https:\/\/www.tcit.cl\/wp-content\/uploads\/2019\/11\/17-SPAS.jpg","contentUrl":"https:\/\/www.tcit.cl\/wp-content\/uploads\/2019\/11\/17-SPAS.jpg","width":1100,"height":750},{"@type":"BreadcrumbList","@id":"https:\/\/www.tcit.cl\/desarrolladores-front-end-tensorflowjs\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Portada","item":"https:\/\/www.tcit.cl\/"},{"@type":"ListItem","position":2,"name":"Aprendizaje autom\u00e1tico para desarrolladores front-end con Tensorflow.js"}]},{"@type":"WebSite","@id":"https:\/\/www.tcit.cl\/#website","url":"https:\/\/www.tcit.cl\/","name":"https:\/\/www.tcit.cl\/","description":"AI Solutions","publisher":{"@id":"https:\/\/www.tcit.cl\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.tcit.cl\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/www.tcit.cl\/#organization","name":"TCIT EIRL","alternateName":"TCIT AI Solutions","url":"https:\/\/www.tcit.cl\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.tcit.cl\/#\/schema\/logo\/image\/","url":"https:\/\/www.tcit.cl\/wp-content\/uploads\/2025\/09\/cropped-TCIT_isotipo-color.png","contentUrl":"https:\/\/www.tcit.cl\/wp-content\/uploads\/2025\/09\/cropped-TCIT_isotipo-color.png","width":512,"height":512,"caption":"TCIT EIRL"},"image":{"@id":"https:\/\/www.tcit.cl\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/web.facebook.com\/tcitcloudsolutions\/","https:\/\/www.instagram.com\/tcitcloudsolutions\/","https:\/\/www.linkedin.com\/company\/tcit-cloud-solutions\/"]},{"@type":"Person","@id":"https:\/\/www.tcit.cl\/#\/schema\/person\/3feac3eca66491ec20151f9127ed7ea1","name":"Gonzalo Burgos","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/e2d4d08554b58b6bdc8ddfc801c6b583fb9207e71f73b8a119ced6a71fc814d0?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/e2d4d08554b58b6bdc8ddfc801c6b583fb9207e71f73b8a119ced6a71fc814d0?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/e2d4d08554b58b6bdc8ddfc801c6b583fb9207e71f73b8a119ced6a71fc814d0?s=96&d=mm&r=g","caption":"Gonzalo Burgos"},"url":"https:\/\/www.tcit.cl\/ingles\/author\/eduardo-albornoz-2\/"}]}},"_links":{"self":[{"href":"https:\/\/www.tcit.cl\/ingles\/wp-json\/wp\/v2\/posts\/4069","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.tcit.cl\/ingles\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.tcit.cl\/ingles\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.tcit.cl\/ingles\/wp-json\/wp\/v2\/users\/9"}],"replies":[{"embeddable":true,"href":"https:\/\/www.tcit.cl\/ingles\/wp-json\/wp\/v2\/comments?post=4069"}],"version-history":[{"count":0,"href":"https:\/\/www.tcit.cl\/ingles\/wp-json\/wp\/v2\/posts\/4069\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.tcit.cl\/ingles\/wp-json\/wp\/v2\/media\/4078"}],"wp:attachment":[{"href":"https:\/\/www.tcit.cl\/ingles\/wp-json\/wp\/v2\/media?parent=4069"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.tcit.cl\/ingles\/wp-json\/wp\/v2\/categories?post=4069"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.tcit.cl\/ingles\/wp-json\/wp\/v2\/tags?post=4069"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}