Comenzamos creando una instancia de Ocean y nuevas cuentas: una cuenta de editor para publicar el conjunto de datos en Ocean Protocol como un nuevo activo, y una cuenta de consumidor para solicitar el servicio de cómputo y ejecutar el algoritmo.
de squid_py import Ocean, Config
de mantaray_utilities.user import create_accountconfiguration = Config (OCEAN_CONFIG_PATH)
ocn = Océano (configuración)
# Crear nuevas cuentas para editor y consumidor
publisher_acct = create_account (faucet_url, wait = True)
consumer_account = create_account (faucet_url, wait = True) Saldo de la cuenta del consumidor en Ocean Testnet.
Publicar un conjunto de datos con un servicio de cómputo
Ahora que tenemos las cuentas configuradas y llenas de algunos tokens ETH y OCEAN, publiquemos un conjunto de datos con un calcular Servicio.
Primero, definimos los atributos del servicio de cómputo. El servicio de cómputo se administra mediante un clúster de Kubernetes y se accede a través de Brizo API, que es el servidor HTTP proxy de los proveedores de datos.
# Construir servicio de cómputo para ser incluido en el activo DDO
cluster = ocn.compute.build_cluster_attributes (
'kubernetes',
'/ cluster / url'
)
contenedores = (ocn.compute.build_container_attributes (
"tensorflow / tensorflow",
"último", "sha256: cb57ecfa6ebbefd8ffc7f75c0f00e57a7fa739578a429b6f72a0df19315deadc")
)
servidores = (ocn.compute.build_server_attributes (
'1', 'xlsize', 16, 0, '16gb', '1tb', 2242244))
provider_attributes = ocn.compute.build_service_provider_attributes (
'Azure', 'Compute power 1', clúster, contenedores, servidores
)
atributos = ocn.compute.create_compute_service_attributes (
precio = 13,
tiempo de espera = 3600,
creador = publisher_acct.address,
date_published = get_timestamp (),
provider_attributes = provider_attributes
)
service_endpoint = Brizo.get_compute_endpoint (ocn.config)
template_id = ocn.keeper.template_manager.create_template_id (
ocn.keeper.template_manager.SERVICE_TO_TEMPLATE_NAME ('compute')
)
service_descriptor = ServiceDescriptor.compute_service_descriptor (
atributos,
service_endpoint,
template_id
)
Brizo es el proxy del servicio del proveedor (una API RESTful). Su trabajo es atender todas las solicitudes de servicio relacionadas con datos.
Luego cree el activo de conjunto de datos y regístrelo en cadena y en el almacén de metadatos (Acuario).
# Obtener ejemplo de metadatos del archivo
metadata = get_metadata_example ()
ddo = ocn.assets.create (
metadatos
publisher_acct,
(descriptor_servicio),
proveedores = (dirección_proveedor),
use_secret_store = False
)
# Verifique que el activo se haya creado correctamente tanto en la tienda de metadatos como en la cadena
activo = ocn.assets.resolve (ddo.did)
afirmar activo y activo.did == ddo.didEl nuevo activo se ha registrado correctamente.
Echemos un vistazo al contenido de una definición de servicio de cómputo.
compute_service = ddo.get_service (ServiceTypes.CLOUD_COMPUTE)
pprint ("Definición del servicio de cómputo: n {}". formato (json.dumps (compute_service.as_dictionary (), indent = 2)))
>> Definición del servicio informático:
{
"type": "compute",
"serviceEndpoint":
"https://brizo.marketplace.dev-ocean.com/api/v1/brizo/services/compute",
"atributos": {
"principal": {
"name": "dataAssetComputingServiceAgreement",
"creador": "0x3f4311103a92a6dE4647f56e9e585120caa821C7",
"fecha de publicación": "2020-05-27T20: 49: 20Z",
"precio": "13",
"tiempo de espera": 3600,
"proveedor": {
"type": "Azure",
"descripción": "Compute power 1",
"medio ambiente": {
"cluster": {
"type": "kubernetes",
"url": "/ cluster / url"
},
"supportContainers": (
{
"image": "tensorflow / tensorflow",
"tag": "último",
"suma de comprobación":
"sha256: cb57ecfa6ebbefd8ffc7f75c0f00e57a7fa739578a429b6f72a0df19315deadc"
}
),
"SupportServers": (
{
"serverId": "1",
"serverType": "xlsize",
"cpu": 16,
"gpu": 0,
"memoria": "16 gb",
"disco": "1tb",
"maxExecutionTime": 2242244
}
)
}
}
},
…
Una muestra completa de un servicio de cómputo vive en squid-py.
Ordenar el servicio de cómputo
Ahora que el conjunto de datos Activo se publica con el servicio informático, veamos cómo solicitar el servicio informático y ejecutar el algoritmo.
# Solicite el servicio de cómputo y envíe el pago
Agreement_id = ocn.compute.order (
ddo.did,
cuenta_consumo,
provider_address = provider_address
)
compute_approval_event = ocn.keeper.compute_execution_condition.subscribe_condition_fulfilled (
acuerdo_id, 30, Ninguno, (), espera = Verdadero, from_block = 0
)
Obteniendo el "compute_execution_condition"Evento indica que el proveedor ha reconocido la solicitud del usuario para el servicio de cómputo y el usuario puede comenzar a ejecutar trabajos de cómputo.
Ejecutando el cálculo
Para comenzar el cálculo, prepararemos los metadatos del algoritmo que incluyen el código del algoritmo en bruto, así como la información requerida sobre el algoritmo.
Alternativamente, el algoritmo y sus metadatos se pueden publicar como un activo en el protocolo oceánico similar a la publicación del conjunto de datos anterior. Ejecutar un algoritmo publicado solo requiere enviar la identificación del algoritmo (el DID del activo), ver squid-py.
# Prepare el script del algoritmo y la descripción
algoritmo_texto = get_algorithm_example ()
# construir el objeto de metadatos del algoritmo para usar en la solicitud de proceso
algoritmo_meta = AlgorithmMetadata (
{
'language': 'python',
'rawcode': algoritmo_texto,
'envase': {
'tag': 'último',
'image': 'amancevice / pandas',
'entrypoint': 'python $ ALGO'
}
}
)
Los "ALGO"Macro en el punto de entrada El atributo se reemplaza con la ruta del algoritmo ejecutable.
Y ahora con todos los parámetros listos, podemos comenzar el trabajo de cálculo utilizando el algoritmo anterior.
job_id = ocn.compute.start (
acuerdo_id,
ddo.did,
cuenta_consumo,
algoritmo_meta = algoritmo_meta
) El trabajo de cálculo comenzó utilizando el algoritmo mencionado anteriormente.
La solicitud de inicio de proceso anterior devolverá un job_id que se puede utilizar para solicitar información de estado y resultados sobre el trabajo en ejecución.
status = ocn.compute.status (Agreement_id, job_id, consumer_account) Estado del trabajo de proceso que se inició.
En este punto, debemos esperar hasta que se complete el trabajo. Podemos seguir verificando el estado del trabajo hasta que recibamos un mensaje de estado "Trabajo completado".
Finalmente, los resultados están listos.
resultado = ocn.compute.result (acuerdo_id, trabajo_id, cuenta_consumo)
print (f'El resultado está aquí: {result.get ('urls') (0)})
Las URL de resultados anteriores se pueden usar para descargar los archivos de resultados directamente.
Puedes probar el ejemplo del cuaderno en datascience.oceanprotocol.com. Inicie sesión con su cuenta github, luego, una vez que JupyterLab se haya cargado, abra el cuaderno s05_compute_to_data y diviértase.
