•      
  •    
  •    

 

 

   

 

   

 

     
 
 

   

 

 

 

 

 

 

     

 
 

 

 

   

 
 
 

 

  •  
  •  
  •    
 

   

 

 

 

 

 

 

   

 

   

 

       

 

   

 

 

 
     

   

 

 

 
 

 

 


 

 

 

 

 
 

 

 
 

 

 

 

 

 

   

 

   

 

 

 

 


 

 


 

 
 

   

 

 

 

 

 

 

 

 

 

 
 

 

 

 

 

 

 

 

 

 

 

 

 
 

 

 

 

 

 
 

   

 

 

 

 

 

 

 

 

 

 

 
 


 

 

 

 

 

 

 

 

 
         

     

 

 

 
 

 

 

 

     

 

 


 

 

 

 

   

 

 

 

     

 

 

 

 

 

 

 

 

 

 

 

 

 

 

   

 

 

 

 

     

   

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

   

 

 

 

 

 

 

  •  
  •  
  •  
  •  

 

 


 

 

 

 

 

 

 

 

 

 

 

 

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

Masterización de IBM COBOL Language – Parte 1 – ENTRENAMIENTO GRATUITO

Este artículo sigue mi introducción al lenguaje COBOL. Le aconsejo que vuelva a leer la primera parte que trata de los principios generales de COBOL. Aquí: https://128mots.com/index.php/2020/10/07/ibm-cobol/ e inglés http://128mots.com/index.php/en/2020/10/07/ibm-cobol-3/ (IBM COBOL FREE TRAINING)

Aquí discutimos los conceptos generales de la estructura de un programa COBOL.

DIVISIÓN DE DATOS

Todos los datos que utilizará el programa se encuentran en la División de Datos. Aquí es donde se cuidan todas las asignaciones de memoria requeridas por el programa. Esta división es opcional.

GESTIÓN DE ARCHIVOS:

ENTRENAMIENTO IBM COBOL GRATIS

FILE SECTION describe los datos enviados o desde el sistema, especialmente los archivos.

El SYNtax en COBOL es el siguiente

DIVISION DE DATOS.
SECCIÓN DE ARCHIVO.
 FD/SD NameOfFile[RECORD CONTAINS intgr CHARACTERS] 
	[BLOCK CONTAINS intgr RECORDS] 
[DATA RECORD IS NameOfRecord].
	[RECORDING MODE IS {F/V/U/S}]

FD describe los archivos y SD los archivos de clasificación.

ARCHIVO EN ENTRADA

En FILE-CONTROL la sentencia será:

           SELECCIONE FMASTER ASSIGN FMASTER
                  ESTADO DEL ARCHIVO W-STATUS-FMASTER.

Si el archivo de entrada está indexado:
           SELECCIONE FMASTER ASSIGN FMASTER
                  ORGANIZACIÓN ESTÁ INDEXADA
                  LA CLAVE DE REGISTRO ES FMASTER-KEY
                  ESTADO DEL ARCHIVO W-STATUS-FMASTER.

En este caso a nivel de archivo-SECTION tendremos:

      FMAITRE como aperitivo  
       FD FMAITRE.
       01 ENR-FMAITRE.
      Declaraciones de las áreas de registro

En el nivel JCL, la declaración tendrá el siguiente formato:
ENTREE DD DSN-SAMPLE. INPUTF,DISP-SHR
ENTRENAMIENTO IBM COBOL GRATIS

ARCHIVO FUERA

La instrucción JCL será:

OUTFILE DD DSN-SAMPLE. OUTPUTF,DISP(,CATLG,DELETE),
LRECL-150,RECFM-FB

RECFM especifica las características de los registros con longitud fija (F), longitud variable (V), longitud variable ASCII (D) o longitud indefinida (U). Los registros que se dice que están bloqueados se describen como FB, VB o DB.

APERTURA Y CIERRE DE ARCHIVO EN LA DIVISIÓN DE PROCEDIMIENTOS

COBOL utiliza mecanismos PROCEDURE DIVISION para realizar aperturas de escritura, cierre y archivo.

Apertura del archivo de entrada:

FICENT DE ENTRADA ABIERTA

Abrir el archivo de salida:

SALIDA ABIERTA FICSOR

Cierre de archivo:

CLOSE FICENT
CLOSE FICSOR

Reproducción de archivos:

LEER ACTENR
AL FINAL MUEVA 'O' AL ÚLTIMO REGISTRO
FIN DE LECTURA

Escritura de archivos

ESCRIBIR SOR-ENR
ENTRENAMIENTO IBM COBOL GRATIS

ENLACES EXTERNOS A RECURSOS (IBM COBOL FREE TRAINING)

A continuación se muestran algunos enlaces que me pareció interesante que también se ocupan de la gestión de archivos con COBOL.

Ejemplo de gestión de archivos de IBM: https://www.ibm.com/support/knowledgecenter/en/SS6SGM_5.1.0/com.ibm.cobol51.aix.doc/PGandLR/ref/rpfio13e.html

Formato REFM: https://www.ibm.com/support/knowledgecenter/en/SSLTBW_2.2.0/com.ibm.zos.v2r2.idad400/d4037.htm

Tutorialespunto un artículo sobre administración de https://www.tutorialspoint.com/cobol/cobol_file_handling.htm

COURSERA COBOL con VSCODE: https://www.coursera.org/lecture/cobol-programming-vscode/file-handling-YVlcf

MEDIUM un interesante artículo para principiantes de COBOL: https://medium.com/@yvanscher/7-cobol-examples-with-explanations-ae1784b4d576

También en su blog: http://yvanscher.com/2018-08-01_7-cobol-examples-with-explanations–ae1784b4d576.html

Muchos ejemplos de tutoriales gratuitos de COBOL y código de ejemplo: http://www.csis.ul.ie/cobol/examples/default.htm

GITHUB Awesome-cobol te https://github.com/mickaelandrieu/awesome-cobol

FORMACIÓN GRATUITA DE IBM COBOL

¿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:

¿Cómo preparé la certificación PRINCE2® Practitioner?

Acabo de obtener la certificación PRINCE2® Practitionner. 

PRINCE2® es una metodología de gestión de proyectos utilizada en todo el mundo que puede adaptarse a todo tipo de proyectos.

Con un salario promedio de $84,450 para un gerente de proyecto certificado, (aquí), tengo que decir que PRINCE2® es desde mi punto de vista un conjunto de habilidades muy interesante para conseguir.

Aprender PRINCE2® es un poco como decir "Quiero trabajar con el mejor método para gestionar y controlar proyectos con un alcance internacional.»

Comparto aquí algunas notas y mis comentarios, así como recursos, que podrían estar interesados en si está considerando certificar PRINCE2®.

El primer paso en la certificación es el examen PRINCE2® Fundamental (PRINCE2® Foundation, que valida que tienes el conocimiento para participar en un proyecto que utiliza el examen PRINCE2®El examen PRIN
CE2® Practitioner (PRINCE2® Practitioner) tiene como objetivo un perfecto dominio del método de gestión y gestión de un proyecto, el examen fundamental es un requisito previo.

Le aconsejo que lea el libro oficial Gestión de proyectos exitosos con PRINCE2®

Disponible aquí:

y usted tiene derecho a ello durante el examen PRINCE2® Practitioner.
Puede optar por aprobar la certificación en francés o inglés. Te aconsejo que lo pases en inglés porque en mi opinión le da un carácter más internacional a la certificación. También tendrá 30 minutos adicionales para tomar el examen si no lo toma en su idioma nativo.

Aquí hay una lista de recursos interesante que encontré en línea:

https://prince2.wiki: Medios gratuitos para ayudarle a aprobar certificaciones PRINCE2®.

Simulador de examen en línea gratuito para PRINCE2® Foundation https://mplaza.training/exam-simulators/prince2-foundation/

Simulador de examen en línea gratuito para PRINCE2® Practitioner https://mplaza.training/exam-simulators/prince2-practitioner/

El sitio web oficial PRINCE2®de Axelos: https://www.axelos.com/best-practice-solutions/prince2

Si estás buscando un libro en francés te recomiendo este:

Propiedad Intelectual
:PRINCE2® y PRINCE2 Agile® son marcas registradas de AXELOS Limited, utilizadas bajo el permiso de AXELOS Limited. Todos los derechos reservados.

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 2

Este artículo sigue el primer artículo sobre el tema: http://128mots.com/index.php/2020/03/30/construire-une-application-decentralisee-full-stack-pas-a-pas-ethereum-blockchain-dapp-en-plus-de-128-mots-partie-1/

Ejemplo de aplicación de votación descentralizada (Dapp)

El usuario de la aplicación descentralizada necesita un monedero que contenga éter. Como se indica en el primer artículo es posible crear fácilmente una cartera en https://metamask.io/.

Primero usaremos la red ropsten. Ropsten Ethereum, también conocido como el "Ethereum Testnet", es, como su nombre indica, una red de prueba que realiza el mismo protocolo que Ethereum y se utiliza para fines de prueba antes de implementar en la red principal (Mainnet). https://ropsten.etherscan.io/

El uso nos permitirá crear y utilizar nuestra aplicación de forma gratuita antes de eventualmente transmitirla en la red principal de Ethereum.

Cuando el usuario se conecta a nuestra aplicación y a la red envía su voto y tiene que pagar algunas tarifas a través de su cartera con el fin de escribir su transacción en el Blockchain (llamado "Gas", este término se refiere a las tarifas para completar una transacción o ejecutar un contrato en la cadena de bloques Ethereum).

Arquitectura de aplicaciones Dapp

La arquitectura de la aplicación consta de un front-end que estará en HTML y Javascript. Este Frontend interactuará directamente con la cadena de bloques ethereum local que instalaremos.

Arquitectura de aplicaciones DAPP

Como se indica en el primer artículo, las reglas de negocio y la lógica se codificarán en un contrato inteligente. El Contrato Inteligente está escrito con el lenguaje de programación de solidez: https://solidity.readthedocs.io

Creación del Front-End

El front-end será simple que le permite mostrar el resultado de la votación para su canción favorita en forma de una lista y elegir de una lista desplegable la canción por la que desea votar.

Comprobar la instalación del nodo

nodo -v

Si el nodo no está instalado, puede consultar mi artículo sobre angular: http://128mots.com/index.php/2020/02/27/angular-en-plus-de-128-mots-partie-1/

Instalación de Metamask: Instalación de https://metamask.io/ como una extensión de su navegador

Instalación del marco de la trufa: La trufa es un entorno de desarrollo, un marco de pruebas y una canalización de activos para Ethereum, con el objetivo de hacer su vida más fácil como desarrollador de Ethereum. Proporciona herramientas que nos permiten escribir contactos inteligentes con el lenguaje de programación Solidity.

También se utilizará para desarrollar el front-end de la aplicación.

npm instalar -g trufa

Instalación de Ganache:

Ganache es una cadena de bloques personal para el desarrollo de Ethereum que puede utilizar para implementar contratos, desarrollar sus aplicaciones y ejecutar pruebas.

https://www.trufflesuite.com/ganache

Esto le permitirá tener una cadena de bloques local con 10 cuentas que están alimentadas con éter falso.

Comencé la aplicación y hice clic en Inicio rápido

Vemos las diferentes cuentas de nuestra cadena de bloques local.

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: