Pop

Curso .NET Core en C# - 12.AddMvc VS AddMvcCore

12. AddMvc VS AddMvcCore

  • 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 adaptar nuestro proyecto para poder utilizar el patrón de diseño  MVC en el anterior capítulo. En este vídeo discutiremos la diferencia entre utilizar el método AddMvc o el método AddMvCCore, a la hora de configurar nuestro proyecto en la clase Startup.cs:
  • Os dejo un enlace al código fuente para que podáis comprobar lo explicado en el vídeo:

Tutorial Open AI Gym - Nuestro bot cobra vida (3/3)

3.Vemos nuestro bot funcionando

  • Hola a todos, en esta ocasión finalizamos 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 acabamos la implementación de nuestro propio agente de juego. Vemos como entrenar al modelo y también podremos contemplar a nuestro bot jugando su primera partida.
  • Código fuente visto en el vídeo:
#Con esta función contruimos nuestros mmodelo.Nuestra red neuronal
def build_model(input_size, output_size):
    model = Sequential()
    model.add(Dense(128, input_dim=input_size, activation='relu'))
    model.add(Dense(52, activation='relu'))
    model.add(Dense(output_size, activation='linear'))
    model.compile(loss='mse', optimizer=Adam())

    return model
#creamos la función que entrenará nuestro modelo
def train_model(training_data):
    X = np.array([i[0] for i in training_data]).reshape(-1, len(training_data[0][0]))
    y = np.array([i[1] for i in training_data]).reshape(-1, len(training_data[0][1]))
    model = build_model(input_size=len(X[0]), output_size=len(y[0]))
    
    model.fit(X, y, epochs=10)
    return model
trained_model = train_model(training_data)


scores = []#inicializamos puntuaciones y array de elecciones
choices = []
for each_game in range(1):#jugamos 100 partidas
    score = 0
    prev_obs = []
    for step_index in range(goal_steps):#Jugamos 500 pasos por partida
        
        env.render()
        if len(prev_obs)==0:
            action = random.randrange(0,2)#en el primer paso elegimos movimiento al azar
        else:
            #A partir del segundo paso conocemos el estado actual del juego.
            #Entonces, tomaremos esa observación y se la daremos a nuestro 
            #modelo para predecir qué acción debemos tomar. 
            action = np.argmax(trained_model.predict(prev_obs.reshape(-1, len(prev_obs)))[0])
        #guardamos elección
        choices.append(action)
        new_observation, reward, done, info = env.step(action)
        prev_obs = new_observation
        score+=reward
        if done:
            break

    env.reset()
    scores.append(score)

print(scores)
print('Average Score:',sum(scores)/len(scores))
print('choice 1:{}  choice 0:{}'.format(choices.count(1)/len(choices),choices.count(0)/len(choices)))

Curso .NET Core en C# - 11.Adaptando nuestro proyecto a MVC

11. Adaptando nuestro proyecto a MVC

  • 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 del MVC en el anterior capítulo. En este vídeo prepararemos el Proyecto Core de ASP.NET con el que hemos estado trabajando hasta ahora.Recordar que utilizamos la plantilla de proyecto "Vacío". Por lo que este proyecto no tiene configuración para MVC. Para configurar el proyecto añadimos:
public void ConfigureServices(IServiceCollection services{services.AddMvc();}
  • También añadimos al método configure las siguientes llamadas:
        app.UseStaticFiles();
    app.UseMvcWithDefaultRoute();
      UseMvcWithDefaultRoute ()

      • En el siguiente vídeo podemos ver como hacemos los pasos necesarios para pasar nuestra aplicación de consola a una aplicación MVC:

      Curso .NET Core en C# - 10.MVC

      10. MVC

      • 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 ocasión empezamos con el modelo-vista-controlador.Todos sabemos que una aplicación típica del mundo real normalmente tiene las siguientes capas.
        • Capa de interfaz de usuario 
        • Capa de lógica de negocios o capa de dominio
        • Capa de acceso a datos
      • MVC se suele utilizar como patrón de diseño arquitectónico para implementar la capa de interfaz de usuario de una aplicación. MVC consta de tres partes fundamentales: 
        • Modelo:El modelo en una aplicación de MVC representa el estado de la aplicación y cualquier lógica de negocios u operaciones que esta deba realizar. 
        • Vista: Las vistas se encargan de presentar el contenido a través de la interfaz de usuario. Puedes pensar en una vista como una plantilla HTML.
        • Controlador: Los controladores son los componentes que controlan la interacción del usuario, trabajan con el modelo y, en última instancia, seleccionan una vista para representarla.
      • Os dejo un vídeo con la explicación:


      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# - 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...