•      
  •    
  •    

 

 

   

 

   

 

     
 
 

   

 

 

 

 

 

 

     

 
 

 

 

   

 
 
 

 

  •  
  •  
  •    
 

   

 

 

 

 

 

 

   

 

   

 

       

 

   

 

 

 
     

   

 

 

 
 

 

 


 

 

 

 

 
 

 

 
 

 

 

 

 

 

   

 

   

 

 

 

 


 

 


 

 
 

   

 

 

 

 

 

 

 

 

 

 
 

 

 

 

 

 

 

 

 

 

 

 

 
 

 

 

 

 

 
 

   

 

 

 

 

 

 

 

 

 

 

 
 


 

 

 

 

 

 

 

 

 
         

     

 

 

 
 

 

 

 

     

 

 


 

 

 

 

   

 

 

 

     

 

 

 

 

 

 

 

 

 

 

 

 

 

 

   

 

 

 

 

     

   

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

   

 

 

 

 

 

 

  •  
  •  
  •  
  •  

 

 


 

 

 

 

 

 

 

 

 

 

 

 

PyTorch ¿Cómo cargar un modelo previamente entrenado?

Existen varios enfoques para registrar (serializar) y cargar (deserializar) patrones de inferencia en PyTorch.

Por ejemplo, es posible que deba cargar un modelo que ya está entrenado y una copia de seguridad que proviene de Internet. Más recientemente respondí a esta pregunta en un foro de debate https://discuss.pytorch.org/t/i-want-to-do-machine-learning-with-android/98753. Aprovecho este artículo para dar algunos detalles.

GUARDA Y CARGA DE UN MODO PRE-TRAINED con load_state_dict

En PyTorch puedes guardar un modelo almacenando en su archivo sus state_dict estos son diccionarios Python, se pueden grabar, actualizar, modificar y restaurar fácilmente, añadiendo una gran modularidad a los modelos y optimizadores de PyTorch.

En mi ejemplo:

ESPNet está respaldado con este método

https://github.com/sacmehta/ESPNet/tree/master/pretrained/encoder

Me las arreglé para cargar el modelo de codificador utilizando la clase ESPNet que hace un load_state_dict

antorcha de importación
modelo - ESPNet(20,encoderFile"espnet_p_2_q_8.pth", p-2, q-8)
ejemplo - torch.rand (1, 3, 224, 224)
traced_script_module - torch.jit.trace (modelo, ejemplo)
traced_script_module.save ("model.pt")

La salida es

¡Codifica cargado!

Tenga en cuenta que ESPNet utiliza la GPU predeterminada y que se requería una adaptación en Model.py en https://github.com/sacmehta/ESPNet/tree/master/train reemplazando:

self.encoder.load_state_dict (torch.load (encoderFile)

Por:

self.encoder.load_state_dict (torch.load (encoderFile,map_location'cpu')

De lo contrario, si no realiza este ajuste no tiene la capacidad de iniciarse en una GPU, obtendrá el siguiente error:

RuntimeError: intentar deserializar un objeto en un dispositivo CUDA, pero torch.cuda.is_available() es False. Si se está ejecutando en una máquina solo para CPU, utilice torch.load con map_location-torch.device ('cpu') para asignar sus almacenamientos a la CPU.
PYTORCH TORCHSCRIPT

COPIA DE SEGURIDAD Y CARGA POR SCRIPT PYTORCH

https://pytorch.org/docs/stable/jit.html

TorchScript es una forma de crear modelos que se pueden crear que se pueden optimizar desde el código PyTorch.

Cualquier programa TorchScript se puede guardar desde un proceso de Python y cargarse en un proceso en el que no haya dependencia de Python.

El código siguiente le permite guardar el modelo ESPNet previamente entrenado que fue respaldado por el método clásico torch.save mediante el uso de TorchScript.

antorcha de importación

modelo - ESPNet(20,encoderFile"espnet_p_2_q_8.pth", p-2, q-8)
ejemplo - torch.rand (1, 3, 224, 224)
traced_script_module - torch.jit.trace (modelo, ejemplo)
#Exemple con TorchScript
torch.jit.save (traced_script_module, "scriptmodel.pth")

Un ejemplo para el cargador a través de TorchScript a continuación:

antorcha de importación
model - torch.jit.load ("scriptmodel.pth")

RECURSOS SOBRE EL TEMA

https://pytorch.org/docs/stable/jit.html

https://pytorch.org/tutorials/beginner/Intro_to_TorchScript_tutorial.html

https://stackoverflow.com/questions/53900396/what-are-torch-scripts-in-pytorch

BCEWithLogitsLoss en PyTorch ¿cómo encontrar la implementación?

Me han preguntado recientemente sobre cómo encontrar el código BCEWithLogitsLoss (https://discuss.pytorch.org/t/implementation-of-binary-cross-entropy/98715/2) para una función llamada en PYTORCH con la función handle_torch_function me lleva algún tiempo entenderlo, y lo compartiré con usted si ayuda:

La pregunta era acerca de BCEWithLogitsLoss – BCELoss + sigmoid() ? Mi respuesta puede ser aplicable si desea analizar el código de todas las funciones que figura en el diccionario ret de https://github.com/pytorch/pytorch/blob/master/torch/overrides.py

BCEWithLogitsLoss es una combinación de BCELOSS + una capa sigmoid i. Esto es más estable numéricamente que el uso de un sigmoid simple seguido de un BCELoss ya que, al combinar las operaciones en una capa, aprovecha el truco log-sum-exp para la estabilidad numérica ver: https://en.wikipedia.org/wiki/LogSumExp

  1. El código de la clase BCEWithLogitsLoss se puede encontrar en https://github.com/pytorch/pytorch/blob/master/torch/nn/modules/loss.py
    def forward(self, input: Tensor, target: Tensor) -> Tensor:
        retorno F.binary_cross_entropy_with_logits (entrada, objetivo,
                                                  self.peso,
                                                  pos_weight-self.pos_weight,
                                                  reducción-auto.reducción)
BCEWithLogitLoss PYTORCH

El Oject F se importa de functionnal.py aquí : https://github.com/pytorch/pytorch/blob/master/torch/nn/functional.py

Encontrará la función llamada

def binary_cross_entropy_with_logits(entrada, destino, peso-Ninguno, size_average-Ninguno,
                                     reducir-Ninguno, reducción 'media', pos_weight-Ninguno):

Llama a la handle_torch_function en https://github.com/pytorch/pytorch/blob/master/torch/overrides.pyYou en
contrará una entrada de la función binary_cross_entropy_with_logits en el ret dictionnary que contiene todas las funciones que se pueden invalidar en pytorch. Esta
es la implementación de Python de torch_functionMore
información en https://github.com/pytorch/pytorch/issues/24015

A continuación, el código al que se llama está
en el Filehttps://github.com/pytorch/pytorch/blob/master/aten/src/ATen/native/Loss.cpp de C++

Tensor binary_cross_entropy_with_logits (const Tensor> entrada, const Tensor&, const Tensor&weight, const Tensor&pos_weight, int64_t 
...
BCEWithLogitLoss PYTORCH

LIENS DE RESSOURCES :

https://pytorch.org/docs/stable/generated/torch.nn.BCEWithLogitsLoss.html

https://discuss.pytorch.org/t/bceloss-vs-bcewithlogitsloss/33586

https://stackoverflow.com/questions/59246416/the-output-of-numerical-calculation-of-bcewithlogitsloss-for-pytorch-example

https://www.semicolonworld.com/question/61244/implementing-bcewithlogitsloss-from-pytorch-in-keras

¿Cómo hago una carrera en COBOL?

COBOL (COmmon Business Oriented Language) es un lenguaje orientado al negocio que es muy adecuado para el procesamiento de datos con alto rendimiento y precisión, es ofrecido por IBM.

Puede estar seguro de que cualquier compra o retiro que realice con su tarjeta de crédito inicie un programa COBOL. Cada día COBOL procesa millones de transacciones. Desde mi punto de vista aprender COBOL es un conjunto de conocimientos muy interesante.

He trabajado con este lenguaje durante más de 10 años y comparto aquí algunas notas que probablemente le permitirán poner sus manos en él.

El mainframe se está modernizando con la capacidad de programar con las últimas herramientas como el editor de código libre VsCode y extensión zowe, así como el editor Z Open, se ejecutan en la nube en entornos como Open Shift e integran principios devops con herramientas como Github, Jenkins, Wazi.

Sintaxis COBOL

El SYNtax de COBOL es bastante simple y es similar al lenguaje natural en inglés.

El código se estandariza según las columnas que pueden describir 5 áreas clave.

Secuencia de área: especifica un número de secuencia de la línea de código a veces, a veces en blanco

Zona del indicador: Puede contener un indicador, por ejemplo – para indicar que la línea es un comentario, D para indicar que la línea se ejecuta sólo en modo de depuración.

UNA ZONA: Contiene divisiones, secciones, párrafos y Lift

B AREA: Sentencias y declaraciones del programa cobol por ejemplo COMPUTE algo…

Identificación de área: espacio para ignorar y dejar en blanco.

También hay palabras reservadas en COBOL que encontrará en el enlace la lista de palabras reservadas en COBOL. https://www.ibm.com/support/knowledgecenter/SSZJPZ_9.1.0/com.ibm.swg.im.iis.ds.mfjob.dev.doc/topics/r_dmnjbref_COBOL_Reserved_Words.html

Divisiones:

El código está estructurado por divisiones que contienen las propias Secciones compuestas por párrafos compuestas por Sentencias y Declaraciones.

Ejemplo de oraciones:

AÑADIR 45 AL PRECIO.

Tenga en cuenta que el punto corresponde a un terminador de ámbito implícito.

Hay 4 divisiones en un programa COBOL:

– DIVISION DE DATOS: permite configurar la gestión de datos que será procesada por el programa.

– IDENTIFICACION DIVISION: Nombre del programa y programador, fecha del programa, propósito del programa.

– QUARTER ENVIRONEMENT: Tipo de uso del ordenador y mapeo entre archivos utilizados en el programa y dataset en el sistema (enlace entre el programa y el sistema)

– DIVISION DE PROCEDIMIENTO: Aquí es donde se encuentra el código de negocio compuesto por los diferentes párrafos a ejecutar.

Las variables en Cobol:

Al igual que en otros idiomas, las letras se pueden utilizar para representar valores almacenados en la memoria.

El nombre de una variable es un máximo de 30 caracteres.

Una cláusula Picture permite determinar el tipo de variable.

PIC 9: La longitud digital está entre corchetes.

PIC 9(5): variable digital de 5 dígitos la longitud máxima para un digital es 18.

PIC A para un personaje

PIC X(11): un alfanumérico con una longitud máxima de 255

Es posible tener tipos editados usando símbolos:

PIC 9(6)V99 para 6 dígitos y 2 decimales separados por comas.

PIC $9,999V99 para representar una cantidad

Tenga en cuenta que COBOL proporciona litros constantes como CEROS, ESPACIO, ESPACIOS, BAJO VALOR …

Más información en este enlace:

https://www.ibm.com/support/knowledgecenter/SS6SG3_4.2.0/com.ibm.entcobol.doc_4.2/PGandLR/ref/rllancon.htm

Si eres nuevo en IBM COBOL y quieres hacer un aprendizaje serio y no demasiado caro, te recomiendo que leas este libro:

Este libro cubre una gran cantidad de temas relacionados con el lenguaje de la máquina, formación de IBM Cobol, OPEN Cobol IDE, DB2 para convertirse en un verdadero programador de Cobol.

Vea también mis artículos:

Algoritmo el problema de la mochila (problema de mochila) en más de 128 palabras

El problema de la mochila algorítmica es interesante y forma parte del primer programa de ciencia digital e informática.

Este problema ilustra los algoritmos glotón que enumeran todas las posibilidades de resolver un problema para encontrar la mejor solución.

El problema de la mochila es un problema de optimización, es decir, una función que debe ser maximizada o minimizada y restricciones que deben cumplirse.

El problema de la mochila

Para una mochila de máxima capacidad de artículos P y N cada uno con su propio peso y un valor establecido, tire los artículos dentro de la mochila para que el contenido final tenga el máximo valor.

Ejemplo de una declaración:

  • Capacidad máxima de la mochila: 11 unidades
  • Número de artículo: 5
  • Valores de objeto: $10.50,20,30.60
  • Peso de los objetos: '1,5,3,2,4'

¿Cuál es el valor máximo que se puede poner en la mochila teniendo en cuenta la restricción de capacidad máxima de la bolsa que es 11?

Algoritmo gluttonoso

Una solución eficaz es utilizar un algoritmo glotón. La idea es calcular la relación valor/peso para cada objeto y ordenar el objeto en función de esta relación calculada.

Toma el objeto con la proporción más alta y agrega hasta que no puedaagregar más.

En versión fraccionaria es posible añadir fracciones de artículo a la mochila.

Implementación del problema en versión no fraccionada

Aquí está una implementación del problema en una versión no fraccionada, es decir, no se puede agregar una fracción de un objeto a la bolsa. Solo se pueden agregar objetos enteros.

itemsac clase: 
    def __init__ (auto, peso, valor, índice): 
        self.index - índice         
        self.weight - peso 
        self.value
        self.report - valor // peso 
  #Fonction para la comparación entre dos ObjectsSac
  #On compara la relación calculada para ordenarlas
    def __lt__ (yo, otros): 
        devolver self.report< other.rapport 
  

def getValeurMax (pesos, valores, capacidad): 
        TableTrie[] 
        para i en el rango: 
            tableTrie.append (ObjectSac (peso[i]s, valore[i]s, i)) 
  
        #Trier los elementos de la bolsa por su informe
        tableTrie.sort (reverse - True) 
  
        MeterValeur - 0
        para el objeto en tableauTrie: 
            WeightCourant - int (object.weight) 
            ValueCourante - int (object.value) 
            si la capacidad - weightsCourant '0: 
                #on añade el objeto a la bolsa
                #On resta capacidad
                capacidad - weightsCourant 
                MeterValeur - ValueCourante
                #On añade valor a la bolsa 
        devolver contraValeur 


Pesos[1,5,3,2,4] 
Valores[10,50,20,30,60] 
capacidad - 11
Valor máximo - getValeurMax (peso, valores, capacidad) 
(valor máximo en la mochila", ValueMax) 

El resultado es el siguiente:

py sacados.py 
Valor máximo en mochila - 120

Implementación del problema en versión fraccionaria

En una versión fraccionaria del problema de la mochila se pueden añadir fracciones de objeto a la mochila.

itemsac clase: 
    def __init__ (auto, peso, valor, índice): 
        self.index - índice         
        self.weight - peso 
        self.value
        self.report - valor // peso 
  #Fonction para la comparación entre dos ObjectsSac
  #On compara la relación calculada para ordenarlas
    def __lt__ (yo, otros): 
        devolver self.report< other.rapport 
  

def getValeurMax (pesos, valores, capacidad): 
        TableTrie[] 
        para i en el rango: 
            tableTrie.append (ObjectSac (peso[i]s, valore[i]s, i)) 
  
        #Trier los elementos de la bolsa por su informe
        tableTrie.sort (reverse - True) 
  
        MeterValeur - 0
        para el objeto en tableauTrie: 
            WeightCourant - int (object.weight) 
            ValueCourante - int (object.value) 
            si la capacidad - weightsCourant '0: 
                #on añade el objeto a la bolsa
                #On resta capacidad
                capacidad - weightsCourant 
                MeterValeur - ValueCourante
                #On añade valor a la bolsa 
            Otro: 
                fracción - capacidad / pesoCouring 
                MeterValeur -Valor Courante - fracción 
                capacidad - int (capacidad - (weightsCourant - fracción)) 
                Romper
        devolver contraValeur 


Pesos[1,5,3,2,4] 
Valores[10,50,20,30,60] 
capacidad - 11
Valor máximo - getValeurMax (peso, valores, capacidad) 
(valor máximo en la mochila", ValueMax) 

El resultado es el siguiente:

py sacados.py 
Valor máximo en mochila - 140.0

Construir una aplicación paso a paso y descentralizada (Ethereum Blockchain Dapp) en más de 128 palabras – Parte 3

Este artículo sigue los dos primeros artículos sobre el tema:

Los primeros 2 artículos proporcionan una mejor comprensión del concepto de blockchain y aplicación descentralizada.

Creación del proyecto

Se crea un directorio para el proyecto de aplicación de votación en canciones.

mkdir vote-song-dapp

Para acelerar el desarrollo utilizaremos una "caja de trufa": https://www.trufflesuite.com/boxes

Es una especie de plantilla, un lienzo de aplicación que le permite centrarse en el Dapp al tener una estructura ya creada.

Basaré mi explicación en la caja de la tienda de mascotas disponible aquí: https://www.trufflesuite.com/tutorials/pet-shop. Este es uno de los primeros tutoriales de trufa para crear un Dapp.

Este cuadro de trufa incluye la estructura básica del proyecto, así como el código de la interfaz de usuario.

Utilice el comando trufero unbox:

trufa unbox pet-shop

Como recordatorio la instalación de la trufa es posible a través del pedido:

npm instalar -g trufa

Si abre la carpeta vote-chason-dapp con vscode, obtendrá el siguiente árbol:

Ejemplo de árbol de proyecto de aplicación Dapp (basado en trufa de tienda de mascotas)
  • contrato: almacenamiento del contrato inteligente de la aplicación
  • Migración: Las migraciones permiten transferir contratos inteligentes a la cadena de bloques Ethereum (prueba local o mainnet). Las migraciones también le permiten vincular contratos inteligentes con otros contratos inteligentes e iniciarlos.
  • node_modules: La carpeta node_modules contiene bibliotecas descargadas de npm.
  • src: Directorio de aplicaciones front-end (cliente)
  • prueba: Almacenamiento de pruebas para la aplicación
  • trufa-config.js: archivo Javascript que puede ejecutar cualquier código necesario para crear la configuración.

Creación del contrato inteligente

Como recordatorio estamos desarrollando una aplicación que permite elegir la canción favorita de los votantes.

Primero crearemos la parte que permite crear un voto para la mejor canción basada en 3 canciones elegibles.

El contrato escrito en solidez es el siguiente:

Contrato de TopChanson
        struct Song
        ID de uint;
        cadena de título;
        contador de uint;
    }
    uint contador públicoDeChansons;
    mapeo (uint - Canción) canciones públicas;

    función addChansonElligible (nomChanson de memoria de cadena) privada
        CounterDeChansons;
        cancion[compteurDeChansons]es - Song (CounterDeChansons, NameChanson, 0);
    }

    Función TopChansons(público)
        addChansonElligible ("Moonlight");
        addChansonElligible ("Mamá los botes pequeños");
        addChansonElligible (Ah! Cocodrilos");
    }

}

Tenga en cuenta el uso de "mapping (uint – Song) canciones públicas;"

Relacionado: https://solidity.readthedocs.io/en/v0.6.6/types.html#mapping-types

Esta estructura de datos nos permitirá almacenar los títulos de las canciones elegibles como una tabla hash. Es decir, una tabla que toma como clave de acceso en nuestro caso un uint que es el ID de la canción y permite recuperar el valor que es un tipo de canción estructurada.

El tipo de canción está estructurado, consulte la documentación de solidez: https://solidity.readthedocs.io/en/v0.6.6/types.html#structs

Aquí hay un caso especial en la característica addChansonElligible, toma en discusión el nombre de la canción que es una cadena de caracteres de cadena. Si no agrega la palabra clave "memory", obtendrá el siguiente error:

TypeError: la ubicación de los datos debe ser "almacenamiento" o "memoria" para el parámetro en función, pero no se ha dado ninguna.

Para la configuración de la función y las variables de retorno, la ubicación de los datos debe explicarse para todas las variables de tipo (struct, mapping, thong).

El contrato se migra a través del pedido:

trufa migrar --reset

Luego obtenemos:

Recopilando tus contratos...
===========================
Compilación de ./contracts/Migrations.sol
Compilación de ./contracts/TopChanson.sol

seguir…

Construir una aplicación paso a paso y descentralizada (Ethereum Blockchain Dapp) en más de 128 palabras – Parte 1

Este artículo tiene como objetivo explicar los conceptos clave de blockchain, dapp (aplicación descentralizada), contrato inteligente y tokenización.

Blockchain

Una cadena de bloques es una base de datos descentralizada, se comparte entre varios nodos que tiene una copia de esa base de datos.

Bloquear

Una solicitud para que un usuario agregue datos a la base de datos es una transacción. Las transacciones se agrupan y se agregan a un bloque en la cadena de bloques.

Tenga en cuenta que todos los datos de este registro compartido, la cadena de bloques, están protegidos por hash criptográfico y validados por un algoritmo que es un consenso entre los usuarios de la red.

Concepto de bloque en una cadena de bloques

Menor

Los menores son usuarios de la red que utilizan un programa para validar nuevas transacciones y registrarlas en la cadena de bloques.

Ejemplo de granja de un minero equipada para calcular transacciones en la cadena de bloques (a través de la resolución de problemas matemáticos y criptográficos complejos), los mineros reciben una "recompensa" por su trabajo.

Blockchain Ethereum

Ethereum es una plataforma de código abierto que utiliza la tecnología blockchain para ejecutar aplicaciones descentralizadas (dapps).

Esta plataforma se basa en la creación de Smart Contract, es un programa que contiene datos y funciones a las que llaman las aplicaciones.

Basado en la cadena de bloques no hay una base de datos centralizada, pero un registro compartido y mantenido en peer to peer por los usuarios.

Esta tecnología se puede utilizar para intercambiar divisas o para crear aplicaciones descentralizadas que llaman a contratos inteligentes y almacenan sus datos en bloques de la cadena de bloques.

Cadena de bloques pública

En una cadena de bloques pública no hay permiso, todo el mundo puede unirse a la red blockchain, lo que significa que puede leer, escribir o participar con una cadena de bloques pública.

Las cadenas de bloques públicas están descentralizadas, nadie tiene control sobre la red y permanecen seguras porque los datos no se pueden cambiar una vez validados en la cadena de bloques.

Plataformas blockchain públicas como Bitcoin, Ethereum, Litecoin son plataformas blockchain no autorizadas, tratando de aumentar y proteger el anonimato del usuario.

Cadena de bloques privada

En una cadena de bloques privada hay restricciones para filtrar quién puede participar en la red y qué transacciones.

Las cadenas de bloques privadas tienden a estar asociadas con herramientas de administración de identidades o con una arquitectura modular en la que puede conectar su propia solución de administración de identidades.

Puede ser un proveedor de servicios de solución de OAuth que usa Facebook, LinkedIn, por ejemplo,…

Token Ethereum

Los tokens o tokens de Ethereum son activos digitales que se construyen a partir de la cadena de bloques Ethereum. Estos son tokens que atestian que tiene un valor (económico, por ejemplo). Estos tokens se basan en la infraestructura existente de Ethereum.

Para almacenar, recibir, enviar éter (criptomoneda en el etereum blockchain) o tokens (que son tokens que son activos digitales), necesita al menos una cuenta. La forma más fácil de crear una cuenta es:

Es posible crear su propio token para crear su aplicación descentralizada que utiliza el ethereum blockchain público.

Tokenización de activos financieros

La tokenización es un método que convierte los derechos de un activo (financiero, inmobiliario…) en tokens digitales (tokens).

Ejemplo para un apartamento de 400.000 euros. Tokenizarconsiste en convertirlo en 400.000 tokens (el número es arbitrario, el problema puede ser de 4 millones o 100 fichas).

Los tokens se emiten en una especie de plataforma que admite contratos inteligentes, por ejemplo en Ethereum. El objetivo es que los tokens se intercambien libremente.

Cuando compras un token, en realidad compras una parte de la propiedad del activo (desde el apartamento de 400.000 euros).

Compra 200.000 fichas y posees la mitad de los activos. El Blockchain es un registro compartido que es inmutable, garantiza que una vez que compre tokens, nadie pueda eliminar su propiedad.

Aplicación descentralizada

Las aplicaciones descentralizadas son aplicaciones que se comunican con la cadena de bloques. La interfaz de aplicación descentralizada es similar a cualquier sitio web o aplicación móvil.

El contrato inteligente representa la lógica central de la aplicación descentralizada.

Ilustración de una DApp que utiliza una cadena de bloques con contratos inteligentes combinados con los saqueadores de Swarm y Whisper.
Fuente: Intercambio de Ethereum Stack

Contrato inteligente

Los contratos inteligentes contienen toda la lógica empresarial de una DApp. Son responsables de leer y escribir datos en la cadena de bloques, por lo que ejecutan la lógica de negocios.

Los contactos inteligentes se escriben en un lenguaje de programación llamado SOLIDITY https://solidity.readthedocs.io, similar a Javascript.

Para leer sobre el tema:

ANGULAR en menos de 128 palabras – TypeScript – Parte 5

Este artículo sigue a los cuatro primeros sobre el tema ANGULAR y trata con el lenguaje TypeScript:

Uso de clases

Al igual que en otros idiomas, una clase permite crear objetos y reúne variables y funciones que están fuertemente relacionadas "Altamente relacionadas"

Ejemplo de clase

Persona de clase
  name: string;
  nombre: string;

  Para ser más
    console.log ('Mi nombre es'- this.name' - this.prenom);
  }
}

Módulos:

El almacenamiento en clase se puede hacer en archivos separados, en este caso es una instrucción de módulo.

Los módulos hacen que la clase sea accesible fuera del archivo. La clase debe exportarse primero a través de "export" para ser un ejemplo visible de person.ts:

clase de exportación Persona
  name: string;
  nombre: string;

  Para ser más
    console.log ('Mi nombre es'- this.name' - this.prenom);
  }
}

ejemplo de archivo hand.ts que importa la clase Person:

importación - Persona - desde "./persona";

dejar que la persona - nueva persona();

Tenga en cuenta que hay módulos Angular que se importarán con la mención @angular ejemplo:

importación - Componente - de '@angular/núcleo';

relacionado:

https://www.typescriptlang.org/docs/handbook/modules.html

https://www.angularchef.com/recette/50/

ANGULAR en más de 128 palabras – Parte 1

Angular es un marco para crear aplicaciones cliente, basado en HTML/CSS y JavaScript/TypeScript.

Angular ofrece las siguientes ventajas:

  • Módulo de patrón revelador: organiza el código en uno o más módulos y proporciona una mejor estructura.
  • Arquitectura limpia y estructurada.
  • Código reutilizable.
  • Aplicación más fácil de probar.

Arquitectura:

  • Front-End: se encarga de la lógica de presentación. Compuesto de HTML / CSS / TypeScript / Angular
  • Backend: se encarga de la lógica empresarial. Compuesto de datos – API

Crear una primera aplicación Angular:

NodeJS: El entorno de ejecución de Node.js incluye todo lo que necesita para ejecutar un programa escrito en JavaScript. Para instalar el vínculo https://node.js.org

Administrador de paquetes de nodos: Esta es una utilidad de control en línea que facilita la instalación de paquetes, gestión de versiones y gestión de dependencias.

Angular-Cli: una interfaz de línea de comandos para automatizar el flujo de trabajo de desarrollo. Le permite:

  • Crea una nueva aplicación Angular.
  • Ejecute un servidor de desarrollo con compatibilidad con "Live Reload" para obtener una vista previa de la aplicación durante el desarrollo.
  • Añade características a tu aplicación Angular.
  • Ejecutar pruebas unitarias
  • Ejecutar pruebas de extremo a extremo
  • Compile la aplicación para su implementación en producción
  • Implementar la aplicación en un servidor

Instalación de pedidos en línea Angular-cli:

npm install -g @angular-cli

Esta notación con 'NPM' permite que los paquetes nPM se espacien fuera de los nombres. Cada usuario y organización en NPM tiene su propio alcance y son los únicos que pueden agregar paquetes.

Esto es útil por varias razones:

  • Permite a las organizaciones indicar claramente qué paquetes son "oficiales" y cuáles no. Por ejemplo, el ámbito @angular, garantiza que fue publicado por el equipo principal de Angular.
  • El nombre del paquete debe ser único dentro de su ámbito de publicación, pero no para todo el registro npm.
    Por ejemplo, el nombre del paquete http ya está tomado en el repositorio principal npm, pero Angular también puede tener angular/http.

Para más detalles, la documentación se puede encontrar en este enlace: https://docs.npmjs.com/

Cree un paquete Angular:

ng nuevo paquete-prueba-angular

Edite el código del proyecto Angular creado:

Te aconsejo que edites el código con el editor vsCode: https://code.visualstudio.com/ o con el editor de código Sublime Text https://www.sublimetext.com/

Si utiliza vscode, el siguiente comando se puede utilizar en la raíz del proyecto.

Código.

Implemente el proyecto angular en el servidor de máquina local:

ng servir

A continuación, se puede buscar en localhost:4200.

Implementación de Python del algoritmo de Dijkstra

Este artículo sigue el siguiente artículo sobre el algoritmo de Dijkstra: https://128mots.com/index.php/2020/02/17/lalgorithme-de-dijkstra-dans-un-graphe-pondere-et-oriente-en-plus-de-128-mots/

Aquí está la implementación de Python del algoritmo

de colecciones importar deque

def dijkstra (gráfico, vértice):
    cola - deque([vertex])
    distancia ' vértice: 0'
    mientras que la cola:
        t - tail.popleft()
        impresión ("Estamos visitando la cumbre" - str(t))
        para vecino en gráfic[t]o:
                tail.append (vecino)
                nouvelle_distance - distancia [t]- gráfico[t][voisin]
                si (vecino no a distancia o nouvelle_distance< distance):></ distance[voisin]):>
                    distanci[voisin]a a nouvelle_distance
                    imprimir ("Actualizar la cumbre" - str (vecino) - " con distancia: " - str(nouvelle_distance))
                    
    distancia de retorno



gráfico ajacence #Liste
gráfico ''A':'B':15,'C':4','B':'E':5','C':':'E':11,'D':2','D':'E':3','E':
distancia - dijkstra (gráfico, 'A')
impresión ("Distancias" - str (distancia))