Autor: https://128mots.com

 

       

   

 

 

 

   

 

 

 

 

•      
•    
•    

 

 

   

 

   

 

 

   

 

 

 

 

     

 

 

   

 

•  
•  
•    

   

 

 

 

 

   

   

       

 

   

 

   

 

 

 

 

 

 

 

 

 

 

 

 

   

   

 

 

 

 

 

   

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

   

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

     

 

 

 

 

 

 

   

 

 

 

 

 

 

 

 

 

 

 

 

 

   

 

 

 

     

   

 

 

 

 

 

 

 

 

   

 

 

 

 

 

 

•  
•  
•  
•  

 

 

 

 

 

 

 

 

 

 

 

 

 

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.

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 Pytorch with python

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)

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

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

Mastering IBM COBOL Language – Part 1 – FREE TRAINING

How do I make a career in COBOL?

Build a step-by-step, decentralized application (Ethereum Blockchain Dapp) in more than 128 words – Part 3

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

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:

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

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

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

¿Cómo hago una carrera en COBOL?

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

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

FORMACIÓN GRATUITA DE IBM 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:

Bases de Python en más de 128 palabras[Partie 1]

El simulador de red Filius en más de 128 palabras

El algoritmo de la k vecina más cercana (KNN) en Python en menos 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

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

• https://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/
• https://128mots.com/index.php/2020/04/02/construire-une-application-decentralisee-full-stack-pas-a-pas-ethereum-blockchain-dapp-en-plus-de-128-mots-partie-2/

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:

• 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…

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.

Menor

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

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:

• En un ordenador, utilice el servicio Metamask para crear un monedero: https://metamask.io/
• En un smartphone, usa una aplicación tipo Monedero De Coinbase: https://wallet.coinbase.com/

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.

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:

• https://medium.com/coinmonks/public-vs-private-blockchain-in-a-nutshell-c9fe284fa39f
• https://www.ethereum-france.com/creer-et-gerer-son-portefeuille-dether-en-2-minutes-avec-myetherwallet-com/
• http://blockchainhub.net/decentralized-applications-dapps/