Pop

Tutorial Open AI Gym - Empezamos a crear nuestro bot (2/3)

2.Empezamos a crear nuestro bot

  • Hola a todos, en esta ocasión continuamos con nuestro  tutorial de open ai gym (Open AI) , que es un conjunto de herramientas para desarrollar y comparar algoritmos de aprendizaje. Es compatible con enseñar a los agentes de todo, desde caminar hasta jugar juegos como Pong o Pinball.
  •  En el siguiente vídeo podemos ver como como empezamos la implementación de nuestro propio agente de juego. Empezamos a explicar el código y las funciones que utilizaremos para poder entrenar a nuestro modelo.
  • Aquí os dejo el código visto en el vídeo:
#Importamos las librerias necesarias para el ejemplo
import gym
import random
import numpy as np
from keras.models     import Sequential
from keras.layers     import Dense
from keras.optimizers import Adam

env = gym.make('CartPole-v1') #creamos nuestro entorno de trabajo
env.reset()
goal_steps = 500  # definimos el número de pasos para el entrenamiento
score_requirement = 60 #puntuación requerida
intial_games = 10000  #Entrenanmiento inicial

#Función que ejecuta un bucle para hacer varias acciones para jugar el 
#juego.Por eso, intentar jugaremos hasta 500 pasos como máximo.
def play_a_random_game_first():
    try:
        for step_index in range(goal_steps):
            #env.render() #PAra representar el juego
            action = env.action_space.sample() #Elegimos acción al azar
            #Acción aleatoria a través de la función que elige los 
            #los resultado del siguiente paso, según la acción pasada como
            #parametro
            observation, reward, done, info = env.step(action)
            print("Paso {}:".format(step_index))
            print("Acción: {}".format(action))
            print("Observacion: {}".format(observation))
            print("Recompensa: {}".format(reward))
            print("Done: {}".format(done))
            print("Info: {}".format(info))
            if done:#Si juego completado
                break
    finally:
        env.reset()

play_a_random_game_first()

def model_data_preparation():
    training_data = []  # inicializamos los arrays con los datos de
    accepted_scores = [] #entrenamiento y las puntuaciones
    #Jugamos 10000 veces para obtener unos datos representativos
    for game_index in range(intial_games):
        score = 0 #inicializamos variables
        game_memory = []
        previous_observation = []
        #inidicamos que se ejeccute 500 veces
        for step_index in range(goal_steps):
            action = random.randrange(0, 2)#Acción aleatoria.Iz=0 y De=1
            observation, reward, done, info = env.step(action)
            #almacenamos puntuacion
            if len(previous_observation) > 0:
                game_memory.append([previous_observation, action])
                
            previous_observation = observation
            score += reward
            if done:
                break
            
        if score >= score_requirement:
            accepted_scores.append(score)
            for data in game_memory:
                if data[1] == 1:
                    output = [0, 1]
                elif data[1] == 0:
                    output = [1, 0]
                training_data.append([data[0], output])
        
        #resteamos entorno y lo mostramos por pantalla
        env.reset()

    print(accepted_scores)
    
    return training_data

training_data = model_data_preparation()

Curso .NET Core en C# - 9.Variables de entorno

9.Variables de entorno

  • Hola a todos. En este nuevo curso, analizaremos todos los conceptos básicos, intermedios y avanzados de ASP.NET Core que nos ayudan a crear aplicaciones web basadas en datos.Al final de este curso, podremos realizar todas las operaciones de un CRUD, es decir, crear, leer, actualizar y eliminar datos  utilizando SQL Server como nuestra base de datos.
  • En esta entrada hablaremos sobre las variables de entorno.Antes de continuar con el vídeo debernos saber que cualquier empresa suele tener tres entornos:
    • Entorno de DESARROLLO: Usamos este entorno para nuestro trabajo de desarrollo diario. Queremos una página de excepciones para programadores si hay una excepción no  controlada para que podamos entender la causa de la excepción y corregirla si es necesario.
    • Entorno de STAGING: La razón principal de este entorno es identificar cualquier problema relacionado con la implementación. Muchas organizaciones, por lo general, configuran su entorno de prueba para interactuar  también con los proveedores de servicios, para completar las pruebas de extremo a extremo.
    • Entorno de producción: el entorno real en vivo, que utilizamos para las actividades diarias. El entorno de producción debe configurarse para la máxima seguridad y rendimiento. Para mayor seguridad, mostramos una Página de error fácil de usar en lugar de la Página de excepciones para desarrolladores. 
  • Ahora sí vamos con el vídeo de hoy:
  • Al final la case que startup  queda así:

 public class Startup
    {

        private IConfiguration _configuration;

        public Startup(IConfiguration configuration)
        {
            _configuration = configuration;
        }

        // This method gets called by the runtime. Use this method to add services to the container.
        // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
        public void ConfigureServices(IServiceCollection services)
        {
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env )
        {

            if (env.IsDevelopment())
            {
                DeveloperExceptionPageOptions d = new DeveloperExceptionPageOptions
                {
                    SourceCodeLineCount = 2
                };
                app.UseDeveloperExceptionPage(d);
            }
            else if( env.IsProduction() || env.IsStaging())
            {
                app.UseExceptionHandler("/Error");
            }
         

            app.Run(async (context) =>
            {
                throw new Exception("sadas");
               await context.Response.WriteAsync("Entorno: " + env.EnvironmentName);
               

            });
        }
    }

Tutorial Open AI Gym - Introducción (1/3)

1.Introducción

  • Hola a todos, en esta ocasión comenzamos un  tutorial de open ai gym (Open AI). Se trata de  un conjunto de herramientas para desarrollar y comparar algoritmos de aprendizaje. Es compatible con enseñar a los agentes de todo, desde caminar hasta jugar juegos como Pong o Pinball.
  •  Básicamente lo que quiero hacer es construir un bot que sepa jugar  de la forma más parecida posible a un humano. Para empezar vamos a hacer el hola mundo que nos preponen en su web.
  • Pero antes de empezar a escribir código veamos un poco de vocabulario:
    • Environment : es como un objeto o interfaz a través del cual nosotros o nuestro robot (agente) del juego  podemos interactuar con el juego y obtener detalles del estado actual, etc. En otras palabras.El entorno donde jugaremos.
    • Step:  Es una función mediante la cual podemos realizar una acción el estado  actual del juego.
    • Action: Lo que queremos que haga.Por ejemplo moverse a la izquierda o a la derecha
    • Observation  (objeto): Por ejemplo, los datos de píxeles de una cámara, los ángulos de unión y las velocidades de unión de un robot,o el estado del tablero en un juego de mesa.
    • Reward (flotar): - Cantidad de recompensa lograda por la acción
    • Done (booleano): si es hora de restablecer el entorno de nuevo. 
    • Info (dict): - información de diagnóstico útil para la depuración.

  • En el siguiente vídeo os cuento todo esto y un poco más:


        Curso .NET Core en C# - 8.Aprende como trabajar con excepciones

        8.Aprende como trabajar con excepciones

        • Hola a todos. En este nuevo curso, analizaremos todos los conceptos básicos, intermedios y avanzados de ASP.NET Core que nos ayudan a crear aplicaciones web basadas en datos.Al final de este curso, podremos realizar todas las operaciones de un CRUD, es decir, crear, leer, actualizar y eliminar datos  utilizando SQL Server como nuestra base de datos.
        • En este vídeo hablaremos sobre como trabajar con excepciones con  ASP.NET Core 2.2. Para ello practicaremos modificando el código del método public void Configure(.......), de la clase startup.cs. Durante la explicación mostrada en el vídeo podremos ver como mostrar más o menos detalle en la traza del error, según el entorno en el que estemos trabajando:
        • Os pongo el código que dejamos finalmente en el método Configure:

             public void Configure(IApplicationBuilder app, IHostingEnvironment env )
                {

                    if (env.IsDevelopment())
                    {
                        DeveloperExceptionPageOptions d = new DeveloperExceptionPageOptions
                        {
                            SourceCodeLineCount = 2
                        };
                        app.UseDeveloperExceptionPage(d);
                    }

                    app.Run(async (context) =>
                    {
                        throw new Exception("Error fatal");
                       await context.Response.WriteAsync(" Metodo run ");
                    });

                }

        Curso .NET Core en C# - 7.Como servir fichero estáticos

        7.Como servir fichero estáticos

        • Hola a todos. En este nuevo curso, analizaremos todos los conceptos básicos, intermedios y avanzados de ASP.NET Core que nos ayudan a crear aplicaciones web basadas en datos.Al final de este curso, podremos realizar todas las operaciones de un CRUD, es decir, crear, leer, actualizar y eliminar datos  utilizando SQL Server como nuestra base de datos.
        •  En el vídeo veremos como nuestra aplicación ASP.NET Core podrá empezar a servir ficheros estáticos.Por defecto, una aplicación ASP.NET Core no servirá este tipo de archivos. El directorio predeterminado para archivos estáticos es wwwroot y este directorio debe estar en la carpeta del proyecto raíz.Como el proyecto no lo tiene lo creamos.
        • Una vez hecho esto copiamos una imagen y creamos un archivos html. Si probamos a ejecutar el programa todavía no  veo la imagen ni el html. Esto se debe a que, en este momento, nuestro proceso de procesamiento de solicitudes de aplicaciones no tiene el software intermedio requerido que puede servir archivos estáticos. El middleware que necesitamos es UseStaticFiles () middleware.
        • En el vídeo tenemos la explicación al completo:
        • Os dejo parte del código visto en el vídeo para poder navegar al documento  nodefault.html:

           public void Configure(IApplicationBuilder app, IHostingEnvironment env )
                {
                    if (env.IsDevelopment())
                    {
                        app.UseDeveloperExceptionPage();
                    }

                    DefaultFilesOptions d = new DefaultFilesOptions();
                    d.DefaultFileNames.Clear();
                    d.DefaultFileNames.Add("nodefault.html");

                    app.UseDefaultFiles(d);
                    app.UseStaticFiles();
                  
                    app.Run(async (context) =>
                    {
                       await context.Response.WriteAsync(" Metodo run ");
                    });

                 
                }

        Chatbot con inteligencia artifical en tensorflow (4/4)

        4. Chatbot con inteligencia artifical  en tensorflow 

        • Hola a todos.En esta ocasión finalizamos con nuestro tutorial para crear y entrenar  nuestro propio chatbot  que se comportará con inteligencia artificial. Para crear un chatbot, o para hacer cualquier tipo de tarea de aprendizaje automático, el primer trabajo que tenemos que hacer es adquirir datos para el entrenamiento.Después  necesitamos  estructurarlos y prepararlos para que se formateen para "la entrada" y "la salida"para que un algoritmo de aprendizaje automático puede digerir. 
        • Una vez tenemos los ficheros necesarios para el entrenamiento, generados en el capítulo anterior. Estamos en disposición de entrenar nuestro modelo. Para entrenar el modelo hago uso del siguiente código alojado en github: https://github.com/daniel-kukiela/nmt-chatbot
        • En el siguiente vídeo podemos ver como configurar el fichero settings para entrenar nuestro modelo.Además podemos ver las primeras interacciones con nuestro chatbot ya entrenado:

        • Como ya habéis visto en el vídeo nuestro chatbot está ingles.Esto es debido al origen de datos que hemos utilizado para el entrenamiento. Además podemos mejorar la "inteligencia" de nuestro chatbot con mayor tiempo de entrenamiento. En mi caso solo entrene al modelo con un mes de todos los disponibles en nuestro origen de datos, que recuerdo fueron los mensajes en los foros de reddit.



        Curso .NET Core en C# - 6.Conociendo el Middleware(2)

        6.Conociendo el Middleware(2)

        • Hola a todos. En este nuevo curso, analizaremos todos los conceptos básicos, intermedios y avanzados de ASP.NET Core que nos ayudan a crear aplicaciones web basadas en datos.Al final de este curso, podremos realizar todas las operaciones de un CRUD, es decir, crear, leer, actualizar y eliminar datos  utilizando SQL Server como nuestra base de datos.
        • Después de ver la teoría sobre el funcionamiento del middleware.En este vídeo vamos a practicar un poco.Para ello nos vamos al método Configure, donde podemos configurar el camino que seguirán las diferentes peticiones que tenga la aplicación.
        • Ahora mismo en la clase startup las peticiones pueden seguir dos caminos:
          • UseDeveloperExceptionPage(): esta ruta responde con la página de excepciones para desarrolladores, si existe una excepción y si el entorno es Development
          •  Método Run(): Este es el middleware que responde a cada solicitud.
        • En el vídeo podéis ver como añadir otros posibles caminos:

        • Finalmente el método configure tendrá un aspecto similar a este:
          public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILogger <Startup> logger )
                {
                    if (env.IsDevelopment())
                    {
                        app.UseDeveloperExceptionPage();
                    }

                    app.Use(async (context,next) =>
                    {
                        logger.LogInformation("xxxxxxxxx");
                        await context.Response.WriteAsync(" Camino 1 ");
                        await next();
                    });

                    app.Use(async (context, next) =>
                    {
                        logger.LogInformation("yyyyyyyyy");
                        await context.Response.WriteAsync(" Camino 2 ");
                        await next();
                    });

                    app.Run(async (context) =>
                    {
                        logger.LogInformation("zzzzzzzzzzzzzzz");
                        await context.Response.WriteAsync(" Camino 3");
                    });
                }

        Curso .NET Core en C# - 5.Conociendo el Middleware

        5.Conociendo el Middleware

        • Hola a todos. En este nuevo curso, analizaremos todos los conceptos básicos, intermedios y avanzados de ASP.NET Core que nos ayudan a crear aplicaciones web basadas en datos.Al final de este curso, podremos realizar todas las operaciones de un CRUD, es decir, crear, leer, actualizar y eliminar datos  utilizando SQL Server como nuestra base de datos.
        • El software intermedio es un software que se ensambla en una canalización de una aplicación para controlar las solicitudes y las respuestas. Cada componente puede hacer lo siguiente:
          • Elegir si se pasa la solicitud al siguiente componente de la canalización.
          • Realizar trabajos antes y después del siguiente componente de la canalización.
        • Los delegados de solicitudes se configuran con los métodos de extensión Run, Map y Use.  La canalización de solicitudes de ASP.NET Core consiste en una secuencia de delegados de solicitud a los que se llama de uno en uno. En el siguiente vídeo lo vemos:
        • Como resumen del vídeo podemos decir que:
          • RUN: La aplicación ASP.NET Core más sencilla posible configura un solo delegado de solicitudes que controla todas las solicitudes. 
          • USE:Podemos encadenar  delegados de solicitudes con Use. 
          • MAP: Las extensiones Map se usan como convenciones para la creación de ramas en la canalización

        Chatbot con inteligencia artifical en tensorflow (3/4)

        3. Chatbot con inteligencia artifical  en tensorflow 

        • Hola a todos.En esta ocasión continuamos con nuestro tutorial para crear y entrenar  nuestro propio chatbot  que se comportará con inteligencia artificial. Para crear un chatbot, o para hacer cualquier tipo de tarea de aprendizaje automático, el primer trabajo que tenemos que hacer es adquirir datos para el entrenamiento.Después  necesitamos  estructurarlos y prepararlos para que se formateen para "la entrada" y "la salida"para que un algoritmo de aprendizaje automático puede digerir. 
        • Una vez que tenemos la base datos preparada,según vimos en la entrada anterior. Podemos generar los ficheros necesarios para el entrenamiento de nuestro modelo. Crearemos dos archivos que tengan preguntas y respuestas. Para ello tomaremos los datos  de la base de datos y adjuntarlos en los archivos de entrenamiento respectivos.
        • En el siguiente vídeo explico el código necesario para hacer esto:
        • Os dejo el código visto en el vídeo:

        import sqlite3
        import pandas as pd

        #En mi caso trabajo con un solo més.En este caso el marzo de 2015
        timeframes = ['2015-03']


        for timeframe in timeframes:
            connection = sqlite3.connect('{}.db'.format(timeframe))# conectamos a la base de datos
            c = connection.cursor()
            limit = 5000 #numero de registros que obtenemo de la base de datos en la consulta
            last_unix = 0
            cur_length = limit
            counter = 0 # contador para 
            test_done = False # boleano que nos indica cuando hemos  terminado

            while cur_length == limit:

                df = pd.read_sql("SELECT * FROM parent_reply WHERE unix > {} and parent NOT NULL and score > 0 ORDER BY unix ASC LIMIT {}".format(last_unix,limit),connection)
                last_unix = df.tail(1)['unix'].values[0]
                cur_length = len(df)

                if not test_done:
                    with open('test.from','a', encoding='utf8') as f:
                        for content in df['parent'].values:
                            f.write(content+'\n')

                    with open('test.to','a', encoding='utf8') as f:
                        for content in df['comment'].values:
                            f.write(str(content)+'\n')

                    test_done = True

                else:
                    with open('train.from','a', encoding='utf8') as f:
                        for content in df['parent'].values:
                            f.write(content+'\n')

                    with open('train.to','a', encoding='utf8') as f:
                        for content in df['comment'].values:
                            f.write(str(content)+'\n')

                counter += 1
                if counter % 20 == 0:
                    print(counter*limit,'rows completed so far')

        Curso .NET Core en C# - 4.Analizamos los ficheros de configuración

        4.Analizamos nuestra primera aplicación

        • Hola a todos. En este nuevo curso, analizaremos todos los conceptos básicos, intermedios y avanzados de ASP.NET Core que nos ayudan a crear aplicaciones web basadas en datos.Al final de este curso, podremos realizar todas las operaciones de un CRUD, es decir, crear, leer, actualizar y eliminar datos  utilizando SQL Server como nuestra base de datos.
        • En este nuevo capítulo analizamos los ficheros de configuración launchsettings.json y el fichero appsettings.json. El fichero launchsettings está en la carpeta propiedades.Este archivo solo se utiliza en la máquina de desarrollo local. En el fichero appsettings guardaremos la configuración de la aplicación. En versiones anteriores de ASP.NET, almacenábamos los ajustes de configuración de la aplicación, como cadenas de conexión de base de datos en el archivo web.config. 
        • En el vídeo os explico con más detalles estos archivos de configuración:

        • Los ficheros de configuración de vuestras aplicaciones tendrán una apariencia similar a esto:
        {
          "iisSettings": {
            "windowsAuthentication": false, 
            "anonymousAuthentication": true, 
            "iisExpress": {
              "applicationUrl": "http://localhost:51775",
              "sslPort": 0
            }
          },
          "profiles": {
            "IIS Express": {
              "commandName": "IISExpress",
              "launchBrowser": true,
              "environmentVariables": {
                "ASPNETCORE_ENVIRONMENT": "Development"
              }
            },
            "Ejemplo1": {
              "commandName": "Project",
              "launchBrowser": true,
              "applicationUrl": "http://localhost:5000",
              "environmentVariables": {
                "ASPNETCORE_ENVIRONMENT": "Development"
              }
            }
          }
        }

        Curso .NET Core en C# - 3.Analizamos nuestra primera aplicación

        3.Analizamos nuestra primera aplicación

        • Hola a todos. En este nuevo curso, analizaremos todos los conceptos básicos, intermedios y avanzados de ASP.NET Core que nos ayudan a crear aplicaciones web basadas en datos.Al final de este curso, podremos realizar todas las operaciones de un CRUD, es decir, crear, leer, actualizar y eliminar datos  utilizando SQL Server como nuestra base de datos.
        • Terminamos el anterior vídeo creando una aplicación web vacía. En este vamos a analizar el significado del método Main() en una aplicación Core de ASP.NET. Si tienes experiencia con versiones anteriores de .NET, una aplicación de consola tiene un método Main() y es el punto de entrada de esa aplicación de consola.El punto importante a tener en cuenta es que, inicialmente, una aplicación Core de  asp.net se inicia como una aplicación de consola.
        • En el siguiente vídeo explicamos el funcionamiento básico de las aplicaciones CORE de ASP.NET: 
        • Os dejo el código de un par de clases vistas en el vídeo:
          • Clase Program:
        using System;
        using System.Collections.Generic;
        using System.IO;
        using System.Linq;
        using System.Threading.Tasks;
        using Microsoft.AspNetCore;
        using Microsoft.AspNetCore.Hosting;
        using Microsoft.Extensions.Configuration;
        using Microsoft.Extensions.Logging;

        namespace Ejemplo1
        {
            public class Program
            {
                public static void Main(string[] args)
                {
                    CreateWebHostBuilder(args).Build().Run();
                }

                public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>WebHost.CreateDefaultBuilder(args).UseStartup<Startup>();
            }
        }

          • Clase Startup:
        using System;
        using System.Collections.Generic;
        using System.Linq;
        using System.Threading.Tasks;
        using Microsoft.AspNetCore.Builder;
        using Microsoft.AspNetCore.Hosting;
        using Microsoft.AspNetCore.Http;
        using Microsoft.Extensions.DependencyInjection;

        namespace Ejemplo1
        {
            public class Startup
            {
                // This method gets called by the runtime. Use this method to add services to the container.
                // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
                public void ConfigureServices(IServiceCollection services)
                {
                }

                // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
                public void Configure(IApplicationBuilder app, IHostingEnvironment env)
                {
                    if (env.IsDevelopment())
                    {
                        app.UseDeveloperExceptionPage();
                    }

                    app.Run(async (context) =>
                    {
                        await context.Response.WriteAsync(System.Diagnostics.Process.GetCurrentProcess().ProcessName);
                    });
                }
            }
        }

        Curso .NET Core en C# - 34.Creamos nuestro propio log

        34.Creamos nuestro propio log Hola a todos. En este curso, analizaremos todos los conceptos básicos, intermedios y avanzados de  ASP.NET...