RavenProtocol - Medium

‍⬛Ravnest Dev Summary 2024

Raven Protocol — Tue, 21 Jan 2025 11:19:30 GMT

1. Published a Research Paper about our framework Ravnest on Arxiv.

Ravnest: Decentralized Asynchronous Training on Heterogeneous Devices

2. Built and deployed a Readthedocs website for Ravnest that contains extensive documentation, feature updates and usage examples.

https://ravnest.readthedocs.io

3. Developed GRPC enabled communication paradigms and restructured codebase.

4. Integrated data compression techniques to our backend, reducing network overhead and improving training efficiency.

5. Common script for all provider roles for ease of deployment. Ravnest automatically infers the role of the providers within clusters.

6. Support for heterogeneous training jobs allowing both CPU and GPU based systems to participate in same training session.

7. Model compute requirement detection improved and automated in clusterize method.

8. Major improvements to our model splitting technique to extend support for contemporary LLMs.

9. Successfully performed initial benchmarking experiments on small LLMs and vision models.

10. Support for Custom Trainer added, allowing developers to define their own training loops for non-conventional training flows.

11. Introduced new Broker role in Ravnest ecosystem that orchestrates decentralized training jobs.

12. Introduced a new compute mode on top of GRPC that supports PyTorch Distributed training for local LAN/Infiniband connected setups through nccl/gloo backends.

13. Secured GPU systems for benchmarking against state of the art frameworks (like MegatronLM by Nvidia and ColossalAI) through sponsorship programs.

14. Positive technical discussions with players in decentralized compute ecosystem towards potential adoption of Ravnest.

OFFICIAL CHANNELS:
Official Email Address: founders@ravenprotocol.com
Official Website Link: http://www.RavenProtocol.com
Official Announcement Channel: https://t.me/raven_announcements
Official Telegram Group: https://t.me/ravenprotocol
Official Twitter: https://twitter.com/raven_protocol
Official Medium: https://medium.com/ravenprotocol
Official LinkedIn: https://linkedin.com/company/ravenprotocol
Official Github: https://www.github.com/ravenprotocol
Official Substack: https://ravenprotocol.substack.com
Official Discord: https://discord.gg/Njq8QxYUKR

🐦‍⬛🪺Ravnest Dev Summary 2024 🎉 was originally published in RavenProtocol on Medium, where people are continuing the conversation by highlighting and responding to this story.

The Blueprints of Ravnest’s Architecture

Raven Protocol — Tue, 06 Feb 2024 11:21:25 GMT

We are thrilled to share the blueprints of Ravnest’s architecture.

Figure 1 depicts the process of matchmaking, cluster formation and model fragmentation into submodels on an intermediary server. The requester and all available compute nodes will connect to this intermediary server to participate and get the training started.

Figure 2 elucidates upon what goes on inside each cluster, running parallelly. It shows how data is fed through the different nodes as micro batches and asynchronous training is achieved using zero-bubble mode parallelism.

Figure 3 shows an overview of how Global model parameter averaging takes place across a set of clusters in accordance with the parallel multi-ring all reduce method described in our arxiv pre-print. This is triggered periodically to sync up model parameters across clusters.

Link to Research Paper: https://arxiv.org/abs/2401.01728

Github Repository: https://github.com/ravenprotocol/ravnest

— The Raven Protocol Team

The Blueprints of Ravnest’s Architecture was originally published in RavenProtocol on Medium, where people are continuing the conversation by highlighting and responding to this story.

Ravnest: Decentralized Asynchronous Training on Heterogeneous Devices

Raven Protocol — Mon, 05 Feb 2024 10:16:22 GMT

We are happy to share that we’ve published a new research paper!

Check the Cornell University arXiv pre-print for Ravnest, our new decentralized algorithm: https://arxiv.org/abs/2401.01728

We request everyone to have a look at this research paper and give us feedback on any improvements for future iterations.

The implementation is underway and the updates can be found on the following GitHub Repository: https://github.com/ravenprotocol/ravnest

Please note that we are not inviting contributions immediately as we are working on the experimental and comparative analysis of our proposed approach and thereby making regular drastic updates to this repository.

— The Raven Protocol Team

Ravnest: Decentralized Asynchronous Training on Heterogeneous Devices was originally published in RavenProtocol on Medium, where people are continuing the conversation by highlighting and responding to this story.

Concurrent Training of a Requester Graph Across Multiple Participating Providers

Raven Protocol — Tue, 13 Jun 2023 12:49:13 GMT

🚀 Release Notes 🚀

We are excited to announce the next version of Ravenverse which supports concurrent training of a Requester Graph across multiple participating Providers.

Requester Side

1. The number of participants required to compute a graph is now determined and set automatically by our backend based on the complexity of the deep learning graph, operations, weight size and a bunch of other parameters. Requesters can no longer set this number manually in the ravop.execute() function.

2. Example scripts based on fine-tuning of GPT-2 model has been added in the Ravenverse GitHub Repository. The Requesters can first generate a “.pt” (pytorch) model file and there and load it up for distributed training in the Ravenverse. As an example, we have added a Poem Generator GPT which can be trained to write poems based on different emotions like fear, anticipation, mystery, horror etc. Additionally, there’s a Number-Sorting application using GPT that takes in an input vector and simply sorts it.

3. Novel optimisation technique implemented for subgraph formation. Significant speedup observed in graph compilation time.

Provider Side

4. Improved ping-pong refresh rate for more rapid assignment of subgraphs to providers.

5. New subgraph computation mechanism with reduced payload size for more efficient transfer of results. Massive speedup observed.

6. Backup provider support for maintaining graph progress in case of disconnect cases.

7. GPU benchmarking metrics revised based on graph complexity.

Our Libraries:

Ravpy: https://pypi.org/project/ravpy/
Ravop: https://pypi.org/project/ravop/
RavDL: https://pypi.org/project/ravdl/

You can find the documentation for each library in the respective repo Readme files. Please try them out and let us know if you run into any problems.

Raven Protocol GitHub: https://github.com/ravenprotocol

Enjoy the new release! ❤️

— The Raven Protocol Team

Concurrent Training of a Requester Graph Across Multiple Participating Providers was originally published in RavenProtocol on Medium, where people are continuing the conversation by highlighting and responding to this story.

New Release Announcement: GPU Support in Ravenverse

Raven Protocol — Mon, 01 May 2023 12:59:28 GMT

Photo by Nana Dua on Unsplash

🚀🚀 Release Notes 🚀🚀

We are excited to introduce GPU support to Ravenverse! Requesters can now have complex Graphs computed by Providers that can contribute GPU resources.

Requester Side Changes:

Requesters can request for GPU resources by specifying the gpu_required=“yes” parameter in the R.Graph function during Graph definition.
Based on the complexity of the Graph, Ravsock generates minimum system and GPU requirements and only allows Providers meeting those requirements to participate.
Requesters can now directly load PyTorch models into RavDL by using the R.model op. This op takes the path to the TorchScript file of the PyTorch model as a parameter and allows distributed training and inference via the Ravenverse.
Requesters can now persist their entire R.model and retrieve from the Ravenverse post training for further use
Significant speed up in compilation, distribution and computation observed.

RavDL: https://github.com/ravenprotocol/ravdl

Provider Side Changes:

Improvements in connectivity checks
list_graphs functions can be used to check for GPU requirements along with system requirements
Providers can only participate in graphs for which they meet the minimum requirements
Computation speed and efficiency increase observed
Memory Usage optimised

Ravpy: https://github.com/ravenprotocol/ravpy

We have included helper codes in our Ravenverse GitHub Repository for Requesters and Providers.

Ravenverse GitHub: https://github.com/ravenprotocol/ravenverse

You can find the documentation for each library in the respective repo Readme files. Please try them out and let us know if you run into any problems.

Raven Protocol GitHub: https://github.com/ravenprotocol

Enjoy the new release! ❤️

— The Raven Protocol Team

New Release Announcement: GPU Support in Ravenverse was originally published in RavenProtocol on Medium, where people are continuing the conversation by highlighting and responding to this story.

New Release Announcement: Selective Participation

Raven Protocol — Wed, 22 Mar 2023 14:56:20 GMT

We are excited to announce a new iteration of Ravenverse!! In this release, our primary focus has been on Selective Participation.

The previous releases of Ravenverse and its supporting libraries relied on the fact that providers can connect to the network any time they wish and if any ongoing requester graphs are being executed at the moment, they will instantly participate and start receiving computations. However, this approach has some caveats. For instance, we observed that if there are no available pending requester graphs in our network, there is practically no point for providers to keep their systems up and running since they won’t be receiving any computations. Also, it was not guaranteed that all providers in our network will definitely receive computations if one requester were to execute their graph. In order to fix these shortcomings of our network, we are introducing a new paradigm in this release — Selective Participation.

Release Notes

Provider side changes (Ravpy v0.16):
https://pypi.org/project/ravpy/

1. Providers must now manually participate in a specific graph. This means that providers no longer need to keep their systems running and wait indefinitely to receive computations. The list of available graphs for computation can be checked by a provider by running the Provider/list_available_graphs.py in the Ravenverse repository.

2. A graph starts execution when its required number of participants is met. The table will show a bunch of information about each graph including System Requirements, Minimum Stake Required, current Active Participants, and the total number of Required Participants in the graph. Before participating in a graph, Providers must ensure that their system meets the system requirements of that specific graph and they must have enough tokens in their ravenverse account to stake.

3. Along with their earnings, the staked amount will be returned back to the provider once they have successfully computed their share of subgraphs and returned back the computation results. However, A portion of the staked amount will be deducted as a penalty if the Provider disconnects from the network before computing all of their share of subgraphs.

4. Once all computations of a Provider are successfully completed, they will automatically get disconnected from the network and are again free to participate in any other new graph. They can also check their earnings on their ravenverse website dashboard.

5. Quality of life improvements like Upload/Download progress bars.

6. Improvements to the benchmarking procedure by utilizing a dummy torch model.

Requester side changes (Ravop v0.12): https://pypi.org/project/ravop/

7. After the compilation of their graph, requesters will now be shown the cost of the graph and the maximum number of allowable participants (providers).

8. The requester must set a required number of participants in the execute function.

9. Once the graph reaches the execution stage, this number of required participants and currently active participants will be broadcasted to all Providers who wish to participate.

We have included helper codes in our Ravenverse GitHub Repository for Requesters and Providers.

Ravenverse GitHub: https://github.com/ravenprotocol/ravenverse

You can find the documentation for each library in the respective repo Readme files. Please try them out and let us know if you run into any problems.

Raven Protocol GitHub: https://github.com/ravenprotocol

Enjoy the new release! ❤️

— The Raven Protocol Team

New Release Announcement: Selective Participation was originally published in RavenProtocol on Medium, where people are continuing the conversation by highlighting and responding to this story.

New Release Announcement: Introducing the revamped versions of Ravpy, RavDL, Ravop libraries

Raven Protocol — Fri, 10 Feb 2023 14:31:48 GMT

🚀🚀 Announcement! 🚀🚀

We are excited to announce a new release of Ravenverse!

Introducing the revamped versions of Ravpy, RavDL, Ravop libraries.

1. Ravpy (v0.15): https://pypi.org/project/ravpy/
2. RavDL (v0.10): https://pypi.org/project/ravdl/
3. Ravop (v0.11): https://pypi.org/project/ravop/

We have included helper codes in our Ravenverse GitHub Repository for Requesters and Providers.

Ravenverse GitHub: https://github.com/ravenprotocol/ravenverse

You can find the documentation for each library in the respective repo Readme files. Please try them out and let us know if you run into any problems.

Release Notes:

Ravdl (v0.10)

Massive performance improvement in Graph computations and model training, thanks to a revamped approach to the backpropagation algorithm.
Added a collection of new layers to the library along with provision for defining Custom layers.
Apart from Sequential Models, Requesters can now create Functional Custom Models. This will allow them to deploy state of the art complex models (like GPT variants) with ease.
Many new Activation functions added to the library.
Deprecated the use of the old ravdl.v1 API. The new ravdl.v2 API is much more intuitive and powerful to use.
Refactoring changes to the ravdl codebase.
Updated RavDL readme with a detailed tutorial on how to use the new ravdl.v2 API.

Ravpy (v0.15)

Added support for new deep learning, machine learning and math ops.
Optimized model training computations.
The mathematical backend for ravpy has been shifted to Pytorch. This will allow us to leverage the power of GPU acceleration and other features in future releases.
FTP broken-pipe connection issues resolved.
Execution of Backpropagation Algorithm has been optimized for better performance.
Refactoring changes to the ravpy codebase.
Minimized the probability of subgraph failure. Improved the robustness of the system with better reassignment strategies in case of mid-computation internet connectivity issues.

Ravop (v0.11)

Added support for new deep learning, machine learning and math ops.
Requesters will now receive the exact error messages in case their graph fails.
The post-execution results of computed ops can now be fetched as torch.Tensor objects.

Ravsock & Scheduler-Service

Major improvements to the scheduler-service. The scheduler-service now uses a more efficient algorithm to generate and assign subgraphs to workers. This will result in faster execution of subgraphs.
Improved handling of failed and redundant subgraphs. Graphs will fail only after 5 re-attempts at execution.
Optimized payload formation due to which the size of the payload has been significantly reduced.
Error serving features for Requester.
Dynamic cleanup for inessential data.
Dynamic split size for graph splitting based on complexity.
Revamped the communication channel between the scheduler-service and the ravsock server running on multiple worker threads.
Added support for new deep learning, machine learning and math ops.

Raven Protocol GitHub: https://github.com/ravenprotocol

Enjoy the new release! ❤️

— The Raven Protocol Team

New Release Announcement: Introducing the revamped versions of Ravpy, RavDL, Ravop libraries was originally published in RavenProtocol on Medium, where people are continuing the conversation by highlighting and responding to this story.

Launching Ravenverse!

Raven Protocol — Thu, 06 Oct 2022 21:46:52 GMT

Hi everyone,

Finally🥁

We are thrilled to announce the public release of Ravenverse.

Raven Protocol is decentralizing computing power and creating a requester-provider economy. And Ravenverse is a significant step forward for Raven Protocol.

As a team, we are constantly evolving and improving. Our team has worked hard on this release and will keep improving Ravenverse. Requesters can now develop operations and models, and providers can join in to offer their idle computing resources in exchange for Raven tokens.

Instructions to use Ravenverse:

Create your Ravenverse account and generate an access token: https://ravenverse.ai (Need Metamask)
Clone Ravenverse repository: https://github.com/ravenprotocol/ravenverse
Put your access token and server credentials in the .env file:
Ravenverse Server Url: http://server.ravenverse.ai
Ravenverse FTP Host/Url: http://server.ravenverse.ai
Create operations and models, or join in to offer your idle computing resources

Enjoy Ravenverse! Please let us know if you run into any problems.
Note: We are working on a no-code UI for requesters and providers.

Launching Ravenverse! was originally published in RavenProtocol on Medium, where people are continuing the conversation by highlighting and responding to this story.

Revamped Federated Analytics for Ravenverse!

Unnikrishnan Menon — Tue, 20 Sep 2022 14:55:39 GMT

On top of Distributed Computing, the Ravenverse now also has support for Federated Analytics (FA), a technique useful for conducting data analysis without directly observing a client’s private data. You can read more on FA here.

This post dives deeper into the working of our improved FA release.

Requester and Provider

In Ravenverse, the Requester is the entity that wants to conduct analysis of statistical metrics across data that is hosted on devices across the globe. They can define certain constraints and filters that the data must conform to. The Ravenverse bridges the gap between the Requesters and these devices by allowing only those devices with valid data (satisfying the constraints) to participate without exposing any private data.

On the other hand, Providers are entities that host cleaned data locally. For instance, it could be the medical records of patients in a hospital.

For the sake of this demo, we will be considering an arbitrary dataset of Office data that consists of 4 columns hosted on the Provider.

Sample Office Data

Getting your Ravenverse Token

Visit the Ravenverse Website (preferably on Chrome) and login using your MetaMask Wallet Credentials. More details on account creation can be found in this article.

Copy your Private Ravenverse Token. This token will be required by all Raven libraries to authenticate transactions and data transfers.

Setup

Clone the Ravenverse Repository

git clone https://github.com/ravenprotocol/ravenverse.git

It is recommended to create a conda virtual environment with python 3.8 for Ravenverse.

Now inside the cloned folder, install the Python dependencies

pip install -r requirements.txt

Requester Side

Inside the Requester subfolder, you should find a .env file in which you need to paste your Ravenverse token.

Running the Script

The Requester’s script (Ravenverse/Requester/create_federated_analytics.py) utilizes the Ravop library to compile and execute FA ops. In this demo, we will be finding the mean, variance and standard deviation of the Office Data hosted on the Provider.

cd Requester/

python create_federated_analytics.py

Let’s dive deeper into the script.

Importing the libraries

import os
from dotenv import load_dotenv
load_dotenv() 
import json
import ravop as R

First, we initialize the requester with their Ravenverse token, after which we clear any previous/existing graphs using the R.flush() method. Note that the initialize function of Ravop fetches the token directly from the .env file.

R.initialize(ravenverse_token=os.environ.get("TOKEN")) 
R.flush()

Next, we define a FA Graph (along with the required data constraints) which groups the forthcoming ops under one roof. This graph is now owned by the Requester.

R.Graph(name="Office Data", approach="federated",
            rules=json.dumps(
                  {"rules": {"age": {"min": 18, "max": 80},
                             "salary": {"min": 1, "max": 5},
                             "bonus": {"min": 0, "max": 10},
                             "fund": {}
                            },
            "max_clients": 1}))

name: The name for the graph set by the requester. Preferably a meaningful name that allows clients to identify the type of dataset desired by the requester.
approach: Set to ‘federated’.
rules: The rules dictionary must contain the names of all the columns of data required by the requester for aggregation and their corresponding constraints as shown above. The clients will then be able to filter their data accordingly. Note: An empty dictionary for a column signifies no constraints. All values in that column shall be considered.
max_clients: The number of clients whose data must be aggregated and returned to the requester.

Next, we define Ops for our statistical analysis.

mean = R.federated_mean()
variance = R.federated_variance()
standard_deviation = R.federated_standard_deviation()

Next, we make our Ops Persist. Ops that have been set to persist can later be retrieved after the execution of the graph is complete.

Note: Make sure that the name parameter for each persisting Op is unique within a graph so that later it can be retrieved.

mean.persist_op(name="mean")
variance.persist_op(name="variance")
standard_deviation.persist_op(name="standard_deviation")

Once all Ops of the graph has been defined, the requester must activate their graph. This step completes the compilation procedure and makes the graph ready for execution. No more Ops can be added to the graph after this.

R.activate()

Upon Activation, the Ravenverse compiles the defined Ops and notifies the Requester of how many Raven Tokens it will cost to execute their graph.

Next, we execute the FA graph. On execution, the Provider nodes will be allowed to participate if they possess the relevant data on their systems. The requester can also track the progress of the graph.

R.execute()
R.track_progress()

Compilation and Execution of FA graph

Once executed, the Requester can fetch the computed results of the Ops that they had previously set to persist.

mean_output = R.fetch_persisting_op(op_name="mean")
print("mean: ", mean_output)

variance_output = R.fetch_persisting_op(op_name="variance")
print("variance: ", variance_output)

standard_deviation_output = R.fetch_persisting_op(op_name="standard_deviation")
print("standard_deviation: ", standard_deviation_output)

These fetched ops will contain a dictionary of values corresponding to each row in the dataset.

The output of fetched FA ops

Provider Side

Inside the Provider subfolder, you should find a .env file in which you need to paste your Ravenverse token.

Running the Script

The Provider’s script (Ravenverse/Provider/run_federated_provider.py) utilizes the Ravpy library to view and participate in existing FA graphs. The Office Data (shown earlier) is already included in the Provider subfolder (Ravenverse/Provider/data/data1.csv).

cd Provider/

python run_federated_provider.py

Let’s dive deeper into this script…

Importing the libraries

import os
from dotenv import load_dotenv
load_dotenv() 
from ravpy.utils import list_graphs
from ravpy.federated.participate import participate
from ravpy.initialize import initialize

First, we initialize the provider with their Ravenverse token. Note that the initialize function of ravpy fetches the token directly from the .env file.

client = initialize(os.environ.get("TOKEN"))

Next, we list the currently active graphs in which the provider can potentially participate.

list_graphs(approach="federated")

Listing currently active graphs

After viewing the rules, the Provider can participate in the graph execution with their local dataset. Note: The dataset must be a .csv file.

participate(graph_id=1, file_path="data/data1.csv")

Participation Logs

After participation, the Provider will be aptly rewarded with Raven Tokens that they can view and withdraw into their Metamask wallet, from their Ravenverse Website dashboard.

Join Our Community

Raven’s GitHub Repositories welcome contributions from developers. We’ll be releasing new versions of Ravenverse and related libraries on a regular basis.

Raven Protocol

Join our discord server to get updates on what comes next

Join the Raven Dev Community Discord Server!

Join us on Telegram

Raven Protocol

Revamped Federated Analytics for Ravenverse! was originally published in RavenProtocol on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introducing RavDL Version 2 for Ravenverse!

Anirudh Rajiv Menon — Fri, 16 Sep 2022 11:40:22 GMT

Training Machine Learning and Deep Learning models on Ravenverse is now faster than ever before. A new and optimised version of our Deep Learning library RavDL as well as various new Machine Learning Ops allow developers to train large models within minutes!

The New & Improved RavDL

The latest release of our Deep Learning library, RavDL, allows developers to access RavDL.v2 which leverages newly added Deep Learning Layer Ops which remove redundancies and reduce the number of Ops that need to be created for a model, leading to an increase in speed and compute efficiency.

Unlike RavDL.v1, the new version abstracts rudimentary Ops into individual layer Ops enabling significantly faster compute speeds and reduced latency.

In terms of usage, there is not much difference when compared to RavDL.v1. An example model is shown below.

from ravdl.v2 import NeuralNetwork
from ravdl.v2.optimizers import RMSprop, Adam
from ravdl.v2.layers import Activation, Dense, BatchNormalization, Dropout, Conv2D, Flatten, MaxPooling2D

model = NeuralNetwork(optimizer=RMSprop(),loss='SquareLoss')

model.add(Dense(n_hidden, input_shape=(n_features,)))
model.add(BatchNormalization())
model.add(Dense(30))
model.add(Dropout(0.9))
model.add(Dense(3))
model.add(Activation('softmax'))

The RavDL repo contains detailed documentation regarding the setup as well as the various layers and features available to developers as of this release.

Machine Learning Ops

With a variety of ML algorithms now available as simple Ravop Operators, training an ML algorithm on the Ravenverse is now as simple as declaring an Op, the dataset being its inputs and the other required arguments can be passed as parameters. The following is an example of how one can define a Linear Regression Op for distributed training.

model = R.linear_regression(R.t(X), R.t(y))
model.persist_op('linear_regression_model')

Once trained, the model can later be retrieved for evaluation as follows:

model = R.fetch_persisting_op(‘linear_regression_model’)
score = model.score(X_test,y_test)

The full list of the available ML Operations is as follows:

Linear Regression
Logistic Regression
K-Nearest Neighbours Classifier
K-Nearest Neighbours Regressor
Naive Bayes
K-Means
Support Vector Machine Classifier
Support Vector Machine Regressor
Decision Tree Classifier
Decision Tree Regressor
Random Forest Classifier
Random Forest Regressor

The Ravenverse repo contains detailed walkthroughs on how to setup Ravop in order to use these Operators.

Join Our Community

Raven’s GitHub Repositories welcome contributions from developers. We’ll be releasing new versions of Ravenverse and related libraries on a regular basis.

Raven Protocol

Join our discord server to get updates on what comes next

Join the Raven Dev Community Discord Server!

Join us on Telegram

Raven Protocol

Introducing RavDL Version 2 for Ravenverse! was originally published in RavenProtocol on Medium, where people are continuing the conversation by highlighting and responding to this story.

RavenProtocol - Medium

‍⬛Ravnest Dev Summary 2024

The Blueprints of Ravnest’s Architecture

Ravnest: Decentralized Asynchronous Training on Heterogeneous Devices

Concurrent Training of a Requester Graph Across Multiple Participating Providers

🚀 Release Notes 🚀

Requester Side

Provider Side

Our Libraries:

New Release Announcement: GPU Support in Ravenverse

Requester Side Changes:

Provider Side Changes:

New Release Announcement: Selective Participation

Release Notes

Provider side changes (Ravpy v0.16): https://pypi.org/project/ravpy/

Requester side changes (Ravop v0.12): https://pypi.org/project/ravop/

New Release Announcement: Introducing the revamped versions of Ravpy, RavDL, Ravop libraries

Release Notes:

Ravdl (v0.10)

Ravpy (v0.15)

Ravop (v0.11)

Ravsock & Scheduler-Service

Launching Ravenverse!

Instructions to use Ravenverse:

Revamped Federated Analytics for Ravenverse!

Requester and Provider

Getting your Ravenverse Token

Setup

Requester Side

Running the Script

Provider Side

Running the Script

Join Our Community

Introducing RavDL Version 2 for Ravenverse!

The New & Improved RavDL

Machine Learning Ops

Join Our Community

Provider side changes (Ravpy v0.16):
https://pypi.org/project/ravpy/