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,...])

Curso .NET Core en C# - 23.Tag Helpers

23.Tag 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. 

• Los  Tag Helpers son nuevos en ASP.NET Core. Comprendamos qué son los Tag Helpers y su uso con un ejemplo. Los Tag Helpers son componentes del lado del servidor. Se procesan en el servidor para crear y representar elementos HTML en archivos Razor. Si tienes alguna experiencia con la versión anterior de ASP.NET MVC, puede estar familiarizado con los tag helper para  HTML.  Los Tag Helpers son similares a los HTML helpers.

• En el siguiente vídeo explico como empezar a trabajar con ellos mediante un ejemplo: