Curso .NET Core en C# - 29.Entity Framework: Creamos nuestras tablas

29.Entity Framework: Creamos nuestras tablas

• Hola a todos. En este 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 crearemos nuestra estructura de base de datos con entity framework core. Para ello es necesario trabajar con migraciones.Usaremos el  Package Manager Console (PMC) o la interfaz de línea de comandos (CLI). Si estás utilizando Visual Studio como yo, usa la consola del Administrador de paquetes y haz lo siguiente:

•  Iniciar Package Manager Console en Visual Studio, haga clic en Ver - Otras ventanas - Package Manager Console
• 1) Utiliza el comando  Add-Migration InitialCreate  para agregar una nueva migración
• 2)Crea los métodos para trabajar con la base de datos.Yo ya los tengo preparados. Ahora codificamos sobreescribiendo el método OnModel
• 3) Utiliza el comnado  Add-Migration SeedAmigoTable que creara dentro de la carpeta migration  un nuevo archivo además de los anteriores
• 4)Update-Database -->Actualiza la base de datos a una migración especificada
• En el siguiente vídeo lo puedes ver con más detalles:

• Código de la clase AppDbContext:

using Microsoft.EntityFrameworkCore;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Threading.Tasks;

namespace Ejemplo1.Models

{

    public class AppDbContext:DbContext

    {

        public AppDbContext(DbContextOptions<AppDbContext> options): base(options)

        {

        }

        public DbSet<Amigo> Amigos { get; set; }

        protected override void OnModelCreating(ModelBuilder modelBuilder)

        {

            modelBuilder.Entity<Amigo>().HasData(new Amigo

            {

                Id = 1,

                Nombre = "Pepe",

                Ciudad = Provincia.Madrid,

                Email = "mail@mimail.es"

            },

            new Amigo

            {

                Id = 2,

                Nombre = "juan",

                Ciudad = Provincia.Lugo,

                Email = "mail@mimail2.es"

            },

            new Amigo

            {

                Id = 3,

                Nombre = "Laura",

                Ciudad = Provincia.Cantabria,

                Email = "mail@mimail3.es"

            }

            );

        }

    }

}

Tensorflow.Tutorial Pix2Pix. 6.Más dataset para pix2pix

6.Más dataset para pix2pix

• Hola a todos. En este curso veremos como funcionan las redes de confrontación generativa condicional (cGAN).Estas redes a partir de una imagen de entrada generan una imagen de salida. El curso esta basado en este tutorial de google:  https://www.tensorflow.org/beta/tutorials/generative/pix2pix

• En esta ocasión os traigo más dataset de imágenes para que entrenéis vuestros propios modelos con otros conjuntos de imágenes. En este enlace podéis descargar algunos de los conjuntos de imágenes diponibles : https://www.kaggle.com/vikramtiwari/pix2pix-dataset

• Si queréis probar algunos de los ejemplos sin necesidad entrenar el modelo os dejo este enlace donde vemos algunos modelos ya entrenados:  https://affinelayer.com/pixsrv/index.html

• Os dejo también un enlace a la documentación técnica con la que nos hemos guiado en este proyecto.Está en ingles: https://arxiv.org/pdf/1611.07004.pdf

• Os dejo un vídeo donde os cuento todo esto más detallado:

Curso .NET Core en C# - 28.Entity Framework: vemos la clase DbContext

28.Entity Framework: vemos la clase DbContext

• Hola a todos. En este 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 veremos  una de las clases más importantes en Entity Framework Core .Lla clase DbContext. Esta es la clase que usaremos en el código de nuestra  aplicación para interactuar con la base de datos subyacente. Es esta clase la que administra la conexión de la base de datos y se usa para recuperar y guardar datos en la base de datos. Para que la clase DbContext pueda realizar cualquier trabajo útil, necesita una instancia de la clase DbContextOptions. La instancia de DbContextOptions lleva información de configuración, como la cadena de conexión, el proveedor de la base de datos que se usará, etc.

• En el siguiente vídeo lo explicamos:

• Os dejo el código de la clase SQLAmigoRepositorio que utilizaremos para conectar con nuestro sql:

 public class SQLAmigoRepositorio:IAmigoAlmacen

    {

        private readonly AppDbContext contexto;

        public SQLAmigoRepositorio(AppDbContext contexto)

        {

            this.contexto = contexto;

        }

        public Amigo nuevo(Amigo amigo)

        {

            contexto.Amigos.Add(amigo);

            contexto.SaveChanges();

            return amigo;

        }

        public Amigo borrar(int Id)

        {

            Amigo amigo = contexto.Amigos.Find(Id);

            if (amigo != null)

            {

                contexto.Amigos.Remove(amigo);

                contexto.SaveChanges();

            }

            return amigo;

        }

        public List<Amigo> DameTodosLosAMigos()

        {

            return contexto.Amigos.ToList();

        }

        public Amigo dameDatosAmigo(int Id)

        {

            return contexto.Amigos.Find(Id);

        }

        public Amigo modificar(Amigo amigo)

        {

            var employee = contexto.Amigos.Attach(amigo);

            employee.State = Microsoft.EntityFrameworkCore.EntityState.Modified;

            contexto.SaveChanges();

            return amigo;

        }

    }

Curso .NET Core en C# - 27.Introducción a Entity Framework Core

27.Introducción a Entity Framework Core

• Hola a todos. En este 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 veremos  una introducción a Entity Framework Core. Si tiene alguna experiencia con versiones anteriores de Entity Framework, encontrará muchas características familiares.¿Qué es EF Core? EF Core es un ORM (Mapeo objeto relacional).Es un software liviano, extensible y de código abierto. Al igual que .NET Core, EF Core también es multiplataforma. Funciona en Windows, Mac OS y Linux. 

• ORM significa Object-Relational Mapper y permite a los desarrolladores trabajar con una base de datos utilizando objetos de la capa de negocio. En resumen, un ORM elimina la necesidad de la mayoría del código de acceso a datos que los desarrolladores generalmente necesitan escribir.Un ORM como EF Core puede hacer todo esto por nosotros y ahorra mucho tiempo. 

• En el siguiente vídeo os explico todo esto con más detalle:

Tensorflow.Tutorial Pix2Pix. 5.Entrenamos el modelo

5.Entrenamos el modelo

• Hola a todos. En este curso veremos como funcionan las redes de confrontación generativa condicional (cGAN).Estas redes a partir de una imagen de entrada generan una imagen de salida. El curso esta basado en este tutorial de google:  https://www.tensorflow.org/beta/tutorials/generative/pix2pix

• En este capítulo entrenamos el modelo.Para entrenar el modelo comenzamos iterando sobre el conjunto de datos, después el generador obtiene la imagen de entrada y nosotros obtenemos una salida generada. El discriminador recibe la imagen de entrada y la imagen generada como la primera entrada. La segunda entrada es input_image y target_image. A continuación, calculamos el generador y la pérdida discriminadora. Luego, calculamos los gradientes de pérdida con respecto a las variables (entradas) del generador y del discriminador y las aplicamos al optimizador. En el siguiente vídeo lo explicamos:

• Vemos el el código del vídeo:

#Con la siguiente función evaluamos el comportamineto del modelo generador que estamos #entrenando le pasamos imágenes de nuestro conjunto de prueba 

EPOCHS = 150

def generate_images(model, test_input, tar):

  # the training=True is intentional here since

  # we want the batch statistics while running the model

  # on the test dataset. If we use training=False, we will get

  # the accumulated statistics learned from the training dataset

  # (which we don't want)

  prediction = model(test_input, training=True)

  plt.figure(figsize=(15,15))

  display_list = [test_input[0], tar[0], prediction[0]]

  title = ['Input Image', 'Ground Truth', 'Predicted Image']

  for i in range(3):

    plt.subplot(1, 3, i+1)

    plt.title(title[i])

    # getting the pixel values between [0, 1] to plot it.

    plt.imshow(display_list[i] * 0.5 + 0.5)

    plt.axis('off')

  plt.show()

  

#Función que enlaza todos los modulos implementados

@tf.function

def train_step(input_image, target):

  with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:

    #El generador toma la imagen de entrada de la función.Esta imagen es comprimida por

    #el encoder y descomprimida por el decoder y obtenemos imagen de salida

    gen_output = generator(input_image, training=True)

    #El discriminador observa lo que ha generado el generador y obtenemos

    #la salida del discriminador

    disc_real_output = discriminator([input_image, target], training=True)

    disc_generated_output = discriminator([input_image, gen_output], training=True)

    #Llamamos a las funciones generator_loss y discriminator_loss, que evaluan 

    #el comportamiento del generador y del discriminador

    gen_loss = generator_loss(disc_generated_output, gen_output, target)

    disc_loss = discriminator_loss(disc_real_output, disc_generated_output)

  #Variable para guardar los gradientes del generador

  generator_gradients = gen_tape.gradient(gen_loss,

                                          generator.trainable_variables)

     #Variable para guardar los gradientes del discrimindaor

  discriminator_gradients = disc_tape.gradient(disc_loss,

                                               discriminator.trainable_variables)

   #Optimizamos

  generator_optimizer.apply_gradients(zip(generator_gradients,

                                          generator.trainable_variables))

  discriminator_optimizer.apply_gradients(zip(discriminator_gradients,

                                              discriminator.trainable_variables))

  

#Definimos la rutina de entrenamiento en la siguiente función.

#A la función le pasamos los dataset de entrenamiento  y de test y el número de épocas.

def fit(train_ds, epochs, test_ds):

  for epoch in range(epochs):

    start = time.time()

    # Bucle para el entrenamiento

    for input_image, target in train_ds:

      train_step(input_image, target)

    clear_output(wait=True)

    for example_input, example_target in test_ds.take(1):

      generate_images(generator, example_input, example_target)

    # Cada 20 epocas salvamos el modelo

    if (epoch + 1) % 20 == 0:

      checkpoint.save(file_prefix = checkpoint_prefix)

    print ('Time taken for epoch {} is {} sec\n'.format(epoch + 1,

                                                        time.time()-start))

#Entrenamos al modelo.En mi caso algo más de un día

fit(train_dataset, EPOCHS, test_dataset)

checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir))

# Run the trained model on the entire test dataset

for inp, tar in test_dataset.take(30):

  generate_images(generator, inp, tar)

  

Curso .NET Core en C# - 26.Damos vida a la vista para crear amigos.

26.Damos vida a la vista para crear amigos.

• Hola a todos. En este 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 veremos como implementar todo lo necesario para dar vida a nuestra vista para crear nuevos amigos. Ya hemos visto en anteriores vídeos que cuando llega una solicitud HTTP a nuestra aplicación MVC, es el método de acción del Controlador el que maneja la solicitud entrante. Por ejemplo si queremos ver los detalles de un amigo hacemos una solicitud GET a la  siguiente URL:  http://localhost:51775/Home/Details/2

• En el vídeo vemos como hacemos los siguientes pasos:

1)Para poder añadir nuevos amigo los primero que hemos hecho es añadir a nuestra interface el método -->   Amigo nuevo(Amigo amigo);

2)En nuestro objeto mock añadimos el método:

        public Amigo nuevo(Amigo amigo){

             amigosLista.Add(amigo)

             return amigo;

        }

3)En el controlador añadimos el siguiente método:

      public RedirectToActionResult Create(Amigo a){

            Amigo amigo = amigoAlmacen.nuevo(a);

           return RedirectToAction("details", new { id = amigo.Id });

        }

4) Como tenemos nuestra vista vinculada al objeto amigo es tan simple como en el objeto amigo hacer las siguientes modificaciones:

        [Required]public string Nombre { get; set; }

        [Required]public string Email { get; set; }

y en el controlador modificamos el método para que si la los campos no están devuelve la vista:

 [HttpPost]

 public IActionResult Create(Amigo a)

       {

          if (ModelState.IsValid){

                Amigo amigo = amigoAlmacen.nuevo(a);

                 return RedirectToAction("details", new { id = amigo.Id });

            }

           return View();

        }

por último modificamos la vista.

Tensorflow.Tutorial Pix2Pix. 4.Construimos el discrimindador

4.Construimos el discriminador

• Hola a todos. En este curso veremos como funcionan las redes de confrontación generativa condicional (cGAN).Estas redes a partir de una imagen de entrada generan una imagen de salida. El curso esta basado en este tutorial de google:  https://www.tensorflow.org/beta/tutorials/generative/pix2pix

• En este capítulo vemos como crear nuestro discriminador de imágenes. En nuestro caso el discriminador observará el resultado generado y nos dirá si es cierto o falso , en relación a lo que el considera una imagen correcta. El discriminador en este caso es una PatchGAN: En vez de devolver cierto o falso devuelve una  cuadricula en el que nos dice por si la parte de la imagen corespondiente a cada cuadricula es verdadedo o falso.

• Código visto en el vídeo:

#Cada bloque en el discriminador es (Conv -> BatchNorm -> Leaky ReLU)

#El discriminador recibira entradas.

#Imagen de entrada y la imagen de destino, que debe clasificar como real.

#Imagen de entrada y la imagen generada (salida del generador), que debe clasificar como #falsa.

#Concatenamos estas 2 entradas juntas en el código (tf.concat ([inp, tar], axis = -1))

def Discriminator():

  initializer = tf.random_normal_initializer(0., 0.02)

  inp = tf.keras.layers.Input(shape=[None, None, 3], name='input_image')#imagen de entrada real

  tar = tf.keras.layers.Input(shape=[None, None, 3], name='target_image')#Imagen del generador

  #concatenamos las dos entradas

  x = tf.keras.layers.concatenate([inp, tar]) # (bs, 256, 256, channels*2)

  #Construimos los distintos bloques

  down1 = downsample(64, 4, False)(x) # (bs, 128, 128, 64)

  down2 = downsample(128, 4)(down1) # (bs, 64, 64, 128)

  down3 = downsample(256, 4)(down2) # (bs, 32, 32, 256)

  zero_pad1 = tf.keras.layers.ZeroPadding2D()(down3) # (bs, 34, 34, 256)

  

  #Añadimos la capa convolucional 

  conv = tf.keras.layers.Conv2D(512, 4, strides=1,

                                kernel_initializer=initializer,

                                use_bias=False)(zero_pad1) # (bs, 31, 31, 512)

  #Añadimos la capa BatchNorm

  batchnorm1 = tf.keras.layers.BatchNormalization()(conv)

  #Añadimos la capa Leaky ReLU

  leaky_relu = tf.keras.layers.LeakyReLU()(batchnorm1)

  zero_pad2 = tf.keras.layers.ZeroPadding2D()(leaky_relu) # (bs, 33, 33, 512)

  #Última capa con único filtro de salida con un canal donde nos dice por cada pixel

  #de la imagen si parece real o no

  last = tf.keras.layers.Conv2D(1, 4, strides=1,

                                kernel_initializer=initializer)(zero_pad2) # (bs, 30, 30, 1)

  #devolvemos el modelo del discriminador

  return tf.keras.Model(inputs=[inp, tar], outputs=last)

  

  #compruebo que todo funciona

discriminator = Discriminator()

#Pasamos dos imagenes y vemos un posible resultado.

#Recordar que todavia no hemos entrenado al modelo

disc_out = discriminator([inp[tf.newaxis,...], gen_output], training=False)

plt.imshow(disc_out[0,...,-1], vmin=-20, vmax=20, cmap='RdBu_r')

plt.colorbar()

#objeto para evaluar el resultado de las imágenes que vayamos obteniendo

loss_object = tf.keras.losses.BinaryCrossentropy(from_logits=True)

#Función para evaluar el comportamiento del discriminador

def discriminator_loss(disc_real_output, disc_generated_output):

  #Diferencia entre la observación de una imagen real y una matriz con todo a unos(representa

  #que la imagen es real) 

  real_loss = loss_object(tf.ones_like(disc_real_output), disc_real_output)

  #Diferencia entre la observación de una imagen generada y una matriz con todo a #ceros(representa que la imagen es fake) 

  generated_loss = loss_object(tf.zeros_like(disc_generated_output), disc_generated_output)

  #La suma evalua el comportamiento del discriminador

  total_disc_loss = real_loss + generated_loss

  return total_disc_loss

  

LAMBDA = 100

#Función para evaluar el comportamiento del generador.

#Le pasamos como parametros el mapa generado por el dicriminador, la imagen generada, 

#y la imagen real  

def generator_loss(disc_generated_output, gen_output, target):

  #Lo contrario al discminador

  gan_loss = loss_object(tf.ones_like(disc_generated_output), disc_generated_output)

  #error absoluto medio

  l1_loss = tf.reduce_mean(tf.abs(target - gen_output))

  #Para la suma además utilizamos el hiperparametro LAMBDA con valor 100

  total_gen_loss = gan_loss + (LAMBDA * l1_loss)

  return total_gen_loss

  

 #Definimos los optimizadores

generator_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5)

discriminator_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5)

#guardamos checkpoints para permitir reanudar el entrenamiento donde nos quedamos

checkpoint_dir = './training_checkpoints'

checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt")

checkpoint = tf.train.Checkpoint(generator_optimizer=generator_optimizer,

                                 discriminator_optimizer=discriminator_optimizer,

                                 generator=generator,

                                 discriminator=discriminator)

Curso diseño de bases de datos 6.Ejemplo diagrama entidad relación.Torneo de ajedrez

6.  Ejemplo diagrama entidad relación.Torneo de ajedrez

• Hola a todos. En esta serie de vídeos pretendo diseñar una base de datos partiendo de unas especificaciones iniciales proporcionadas por un cliente. En este cuarto vídeo creamos nuestro diseño de base de datos con gestor  el de base de datos SQL SERVER.

• En este capítulo haremos el diseño del modelo entidad relación del siguiente enunciado:

Un club de ajedrez es encargado de organizar un campeonato.Por este motivo, desea llevar a una base de datos toda la gestión relativa a participantes, alojamientos y partidas. 

Teniendo en cuenta que:

-En el campeonato participan jugadores y árbitros, de ambos se requiere conocer el número de asociado, nombre, dirección y teléfono de contacto. 

De los jugadores se precisa además el nivel de juego en una escala de 1 a 10.

- Ningún árbitro puede participar como jugador.

- Los países envían al campeonato un conjunto de jugadores y árbitros, aunque no todos los países envían participantes. Todo jugador y árbitro es enviado por un único país.

Un país puede ser representado por otro país.

-Cada país se identifica por un número correlativo según su orden alfabético e interesa conocer además su nombre y el número de clubes de ajedrez existentes en el mismo.

-Cada partida se identifica por un número correlativo (CódigoPartida), la juegan dos jugadores y la arbitra un árbitro. Interesa registrar las partidas que juega cada jugador 

y el color (blancas o negras) con el que juega. Ha de tenerse en cuenta que un árbitro no puede arbitrar a jugadores enviados por el mismo país que ha enviado él.

-Todo participante participa en al menos una partida.

Tanto jugadores como árbitros se alojan en uno de los hoteles en los que se desarrollan las partidas, se desea conocer en qué hotel y en qué fechas se ha alojado 

cada uno de los participantes.De cada hotel, se desea conocer el nombre, la dirección y el número de teléfono.

-El campeonato se desarrolla a lo largo de una serie de jornadas (año, mes, día) y cada partida tiene lugar en una de las jornadas aunque no tengan lugar partidas todas las jornadas.

-Cada partida se celebra en una de las salas de las que pueden disponer los hoteles, se desea conocer el número de entradas vendidas en la sala para cada partida. 

De cada sala, se desea conocer la capacidad y medios de que dispone (radio, televisión, vídeo,…) para facilitar la retransmisión de los encuentros. 

Una sala puede disponer de varios medios distintos.

-De cada partida se pretende registrar todos los movimientos que la componen, la identificación de movimiento se establece en base a un número de orden 

dentro de cada partida, para cada movimiento se guardan la jugada (5 posiciones) y un breve comentario realizado por un experto.

• En el vídeo iremos comentando como hacer el diseño:

Curso .NET Core en C# - 25.Creamos vista de usuario con Tags Helpers

25.Creamos vista de usuario con Tags Helpers

• Hola a todos. En este 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 vamos a crear el mecanismo necesario para crear una vista donde poder añadir nuevos amigos.Vamos a utilizar tags helpers.Utilizamos los siguientes a tags helpers para crear un formulario en ASP.NET Core:
• Form Tag Helper
• Label Tag Helper
• Input Tag Helper
• Select Tag Helper
• En el siguiente vídeo lo podemos ver con más detalles:

• Parte del código visto en el vídeo:

• Vista Create.cshtml:

    <form asp-controller="Home" asp-action="Create" method="Post" class="m-2">

        <div class="form-group row">

            <label asp-for="Nombre" class="col-sm-2 col-form-label"></label>

            <div class="col-sm-10">

                <input asp-for="Nombre" class="form-control" placeholder="Nombre" />

            </div>

        </div>

        <div class="form-group row">

            <label asp-for="Email" class="col-sm-2 col-form-label"></label>

            <div class="col-sm-10">

                <input asp-for="Email" class="form-control" placeholder="E-mail" />

            </div>

        </div>

        <div class="form-group row">

            <label asp-for="Ciudad" class="col-sm-2 col-form-label"></label>

            <div class="col-sm-10">

                <select asp-for="Ciudad" class="custom-select mr-sm-2" asp-items="Html.GetEnumSelectList<Provincia>()"></select>

            </div>

        </div>

        <div class="form-group row">

            <div class="col-sm-10">

                <button type="submit" class="btn btn-primary">Nuevo</button>

            </div>

        </div>

• Código de la clase Provincia:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Threading.Tasks;

namespace Ejemplo1.Models

{

    public enum Provincia

    {

        Ninguna, Albacete, Alicante, Almería, Álava, Asturias, Ávila, Badajoz, Baleares, Barcelona, Bizkaia,

        Burgos, Cáceres, Cádiz, Cantabria, Castellón, CiudadReal, Córdoba, Coruña, Cuenca, Guipuzcoa,

        Girona, Granada, Guadalajara, Huelva, Huesca, Jaén, León, Lleida, Lugo, Madrid, Málaga, Murcia,

        Navarra, Ourense, Palencia, Palmas, Pontevedra, Rioja, Salamanca, Tenerife, Segovia, Sevilla,

        Soria, Tarragona, Teruel, Toledo, Valencia, Valladolid, Zamora, Zaragoza, Ceuta, Melilla

    }

}

Curso .NET Core en C# - 24.Creamos un menú con BootStrap.

24.Creamos un menú con BootStrap

• Hola a todos. En este 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 veremos como configurar nuestra aplicación para que coja nuestro fichero de bootstrap de un lugar u otro. Para facilitar la depuración, en nuestra máquina de desarrollo local (es decir, en el entorno de desarrollo) queremos que la aplicación cargue el archivo css de nuestra ruta local. En los entornos de producción o staging queremos que la aplicación cargue el archivo de arranque de CSS (bootstrap.min.css) desde un CDN (Red de distribución de contenidos) para un mejor rendimiento.Sin embargo, si el CDN está caído o por alguna razón, nuestra aplicación no puede llegar al CDN, queremos que nuestra aplicación se repliegue y cargue el archivo de arranque desde nuestro propio servidor web de aplicaciones.

• Además creamos un menú aplicando bootstrap.En el siguiente vídeo lo podemos ver con más detalles:

• Os dejo parte del código visto en el vídeo:

   <environment exclude="Development">

        <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css"

              integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm"

              crossorigin="anonymous"

        href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css"

        asp-fallback-href="~/lib/twitter-bootstrap/css/bootstrap.css"

        asp-fallback-test-class="sr-only" 

        asp-fallback-test-property="position"

        asp-fallback-test-value="absolute"

        asp-suppress-fallback-integrity="true" />

    <div class="container">

        <nav class="navbar navbar-expand-sm bg-dark navbar-dark">

            <a class="navbar-brand" asp-controller="home" asp-action="index">

                <img src="~/images/Amigos.png" width="30" height="30">

            </a>

            <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#collapsibleNavbar">

                <span class="navbar-toggler-icon"></span>

            </button>

            <div class="collapse navbar-collapse" id="collapsibleNavbar">

                <ul class="navbar-nav">

                    <li class="nav-item">

                        <a class="nav-link" asp-controller="home" asp-action="index">Listado</a>

                    </li>

                    <li class="nav-item">

                        <a class="nav-link" asp-controller="home" asp-action="create">Crear</a>

                    </li>

                </ul>

            </div>

        </nav>

        <div>

            @RenderBody()

        </div>

            @RenderSection("Scripts", required: false)

      

    </div>

Tensorflow.Tutorial Pix2Pix. 3.Construimos el generador

3.Construimos el generador

• Hola a todos. En este curso veremos como funcionan las redes de confrontación generativa condicional (cGAN).Estas redes a partir de una imagen de entrada generan una imagen de salida. El curso esta basado en este tutorial de google:  https://www.tensorflow.org/beta/tutorials/generative/pix2pix

• En este capítulo vemos como crear nuestro generador de imágenes. En el siguiente vídeo tenemos la explicación y más abajo os dejo el código visto en el vídeo:

• Código visto en el vídeo:

#cargamos las imagenes de entrenamiento en un dataset
train_dataset = tf.data.Dataset.list_files(PATH+'train/*.jpg')
#data.experimental.AUTOTUNE -->Permite que sea el propio 
#TS el que ajuste el número de hilos en paralelo 
train_dataset = train_dataset.map(load_image_train,
                                  num_parallel_calls=tf.data.experimental.AUTOTUNE)
train_dataset = train_dataset.cache().shuffle(BUFFER_SIZE)
train_dataset = train_dataset.batch(1)

#for im1,img2 in train_dataset.take(3):
    #plt.imshow(((im1[0,...])+1)/2)
    #plt.imshow(((img2[0,...])+1)/2)
    #plt.show()

#cargamos las imagenes de test en otro dataset
test_dataset = tf.data.Dataset.list_files(PATH+'test/*.jpg')
test_dataset = test_dataset.map(load_image_test)
test_dataset = test_dataset.batch(1)

#for im1,img2 in test_dataset.take(3):
    #plt.imshow(((im1[0,...])+1)/2)
    #plt.imshow(((img2[0,...])+1)/2)
    #plt.show()

OUTPUT_CHANNELS = 3

#   Cada bloque en el codificador es (Conv -> Batchnorm ->  ReLU)
#                                    (Covoulución-->Normalizacion-->Activación)
#Función para generar los bloques de nuestro codificador:
def downsample(filters, size, apply_batchnorm=True):
    initializer = tf.random_normal_initializer(0., 0.02)
 
    result = tf.keras.Sequential()
    #añadimos la capa convolucional
    result.add(
    tf.keras.layers.Conv2D(filters, size, strides=2, padding='same',
                             kernel_initializer=initializer, use_bias=False))
  #añadimos capa normalización  
    if apply_batchnorm:
        result.add(tf.keras.layers.BatchNormalization())
  #añadimos capa activación
    result.add(tf.keras.layers.LeakyReLU())

    return result

down_model = downsample(3, 4)
down_result = down_model(tf.expand_dims(inp, 0))
print (down_result.shape)

# Cada bloque en nuestro decodificador es (Transposed Conv -> Batchnorm -> Dropout -> #ReLU)
def upsample(filters, size, apply_dropout=False):
    initializer = tf.random_normal_initializer(0., 0.02)

    result = tf.keras.Sequential()
    #añadimos la capa convolucional inversa
    result.add(
    tf.keras.layers.Conv2DTranspose(filters, size, strides=2,
                                    padding='same',
                                    kernel_initializer=initializer,
                                    use_bias=False))
    #añadimos capa normalización  
    result.add(tf.keras.layers.BatchNormalization())
    #añadimos capa dropout
    if apply_dropout:
       result.add(tf.keras.layers.Dropout(0.5))
   
    #añadimos capa activación
    result.add(tf.keras.layers.ReLU())

    return result

up_model = upsample(3, 4)
up_result = up_model(down_result)
print (up_result.shape)

#Empezamos a construir el generador:
# El generador es una U-Net modificada.
def Generator():
  #Construimos los distintos bloques utilizando las funciones definidas anteriormente
  down_stack = [
    downsample(64, 4, apply_batchnorm=False), # (bs, 128, 128, 64)
    downsample(128, 4), # (bs, 64, 64, 128)
    downsample(256, 4), # (bs, 32, 32, 256)
    downsample(512, 4), # (bs, 16, 16, 512)
    downsample(512, 4), # (bs, 8, 8, 512)
    downsample(512, 4), # (bs, 4, 4, 512)
    downsample(512, 4), # (bs, 2, 2, 512)
    downsample(512, 4), # (bs, 1, 1, 512)
  ]
#Construimos los distintos bloques utilizando las funciones definidas anteriormente
  up_stack = [
    upsample(512, 4, apply_dropout=True), # (bs, 2, 2, 1024)
    upsample(512, 4, apply_dropout=True), # (bs, 4, 4, 1024)
    upsample(512, 4, apply_dropout=True), # (bs, 8, 8, 1024)
    upsample(512, 4), # (bs, 16, 16, 1024)
    upsample(256, 4), # (bs, 32, 32, 512)
    upsample(128, 4), # (bs, 64, 64, 256)
    upsample(64, 4), # (bs, 128, 128, 128)
  ]

  initializer = tf.random_normal_initializer(0., 0.02)
  #Capa convolucional para la imgen que queremos generar 
  #Les especificamos OUTPUT_CHANNELS(tres canales de color)
  # El tipo de activación debe ser el parecido a la normalización[-1,1] que definimos 
  # utilizamos una capa de activación que cumpla esto (tanh) 
  last = tf.keras.layers.Conv2DTranspose(OUTPUT_CHANNELS, 4,
                                         strides=2,
                                         padding='same',
                                         kernel_initializer=initializer,
                                         activation='tanh') # (bs, 256, 256, 3)

  concat = tf.keras.layers.Concatenate()

  inputs = tf.keras.layers.Input(shape=[None,None,3])
  x = inputs

  # Conectamos las capas del codificador
  skips = [] #Guardamos los diferentes elementos en un array para las skip connections
             #que son conexiones que se saltan el procesamiento de algunas capas
  for down in down_stack:
    x = down(x)
    skips.append(x)#alamcenamos en array los elementos

  #La ultima capa de debe ser la primera en el decodificador
  skips = reversed(skips[:-1])

  # Conectamos las capas del decodificador  
  for up, skip in zip(up_stack, skips):
    x = up(x)
    x = concat([x, skip])#Gracias a keras podemos concatenae el resultado de dos capas

  x = last(x)
  #devolvemos un modelo compuesto por todas las capas creadas previamente
  return tf.keras.Model(inputs=inputs, outputs=x)

generator = Generator()

gen_output = generator(inp[tf.newaxis,...], training=False)
plt.imshow(gen_output[0,...])