Welcome to the fifth and last day of the first Livebook Launch Week!

Today we will talk about data wrangling with Livebook and the new data capabilities with this new release.

Watch the video where José Valim shows a demo of those new features.

You can also read an overview of the new features below.

Explorer: series and dataframes for fast data exploration in Elixir

Explorer is a project that brings series (one-dimensional data) and data frames (two-dimensional data) right into Elixir.

It is implemented on top of the Polars project, a highly performant dataframe Rust library. And it’s highly inspired by the dplyr project from R, which is quite expressive. We aim to bring ideas from both communities into Elixir to provide a powerful and elegant tool for data processing.

Let’s play with Explorer a little bit.

The first step of a data exploration project is to import the data. Let’s see how you can import a dataset into an Explorer data frame:

After importing the data, it’s usually a good idea to explore it a little bit. To do that, we’ll use a new feature from Livebook that helps us visualize an Explorer Dataframe as a table.

Visualizing an Explorer dataframe as an interactive table

Kino is the library used by Livebook to render rich and interactive outputs directly from your Elixir code. Livebook has multiple built-in Kinos, but anyone can also build custom Kinos as a way to extend Livebook.

We built a new Kino called Kino Explorer for this release to improve the integration between Explorer and Livebook. Let’s see how we can use it to display an Explorer data frame as an interactive table:

Data transformation using the new Data Transform Smart cell

In Livebook, a Smart cell is a UI-based cell that helps you to accomplish a specific task like creating a database connection, sending a message to a Slack channel, or running a Machine Learning model.

Livebook has various built-in Smart cells, and anyone can build a Smart cell to extend Livebook to their needs.

For this release, we built a new built-in Smart cell; the Data Transform one. Let’s see how we can use it for some data transformation.

What now?

Want to play with all of those new features?

First, ensure you’ve installed the latest version of Livebook.

Then, click the button below to run the notebook that José Valim built in the demo video:

If you have any comments or want to share what you’ve built using Livebook, you can tweet using the #LivebookLaunchWeek hashtag.

I hope you got as excited as we did with this new Livebook 0.9 release.

Besides that, we’re already working on much more exciting stuff we’re looking forward to sharing—for example, the upcoming Livebook Teams.

If you use or want to use Livebook at work with your colleagues, you can fill in our form to help us to inform Livebook Team’s roadmap and get updates about it.

Thank you very much for being with us these last five days. This is all for this first Livebook Launch Week!

Building Livebook and sharing what it’s capable of is a joy for us. We hope you can have fun with it too. 😄

More Launch Week

• Day 1: Deploy notebooks as apps & quality-of-life upgrades
• Day 2: Distributed² Machine Learning notebooks with Elixir and Livebook
• Day 3: Hubs and secret management
• Day 4: Build and deploy a Whisper chat app to Hugging Face in 15 minutes

Welcome to the fourth day of Livebook Launch Week! 🎉

Today we will build a Whisper chat app with Livebook and deploy it to Hugging Face.

In this chat app, users can communicate only by sending audio messages, which are then automatically converted to text by the Whisper Machine Learning model:

You can access the demo over the next few days on José Valim's Livebook instance on HuggingFace.

This demo covers a lot of cool features from Livebook, Nx, and Bumblebee, like:

• Deploy Livebook notebooks as apps

  On day 1 of our Launch Week, we saw how to deploy your notebook as an interactive web app. This time we’ll go further and deploy a Machine Learning-based app to Hugging Face.

• Realtime and multiplayer apps

  Livebook’s modern approach to code notebooks brings interactivity and collaboration. So, apps built with Livebook are also interactive and multiplayer by default! The Whisper chat app we’ll be an excellent example of that.

• Concurrent Machine Learning

  On day 2 of our Launch Week, we talked about the new Machine Learning models you can use with just a few clicks through Livebook’s Neural Network Smart Cell. In today’s video, you’ll see how to customize the code generated by the Smart cell and build an app on top of it.

  We’ll add concurrency and batching to improve the app’s scalability and performance, allowing multiple users to submit audio messages simultaneously and efficiently process them using the Whisper model.

What now?

Want to run the Whisper chat app by yourself?

First, ensure you’ve installed the latest version of Livebok.

Then, click the button below to run the notebook yourself:

If you have any comments or want to share what you’ve built using Livebook, you can tweet using the #LivebookLaunchWeek hashtag.

Stay tuned for the final announcement of the Livebook Launch Week!

More Launch Week

• Day 1: Deploy notebooks as apps & quality-of-life upgrades
• Day 2: Distributed² Machine Learning notebooks with Elixir and Livebook
• Day 3: Hubs and secret management
• Day 5: Data wrangling in Elixir with Explorer, the power of Rust, the elegance of R

Welcome to the third day of Livebook Launch Week! 🎉

In today’s post, we’ll explore the new security features in Livebook 0.9, including the introduction of Hubs for centralized secret management and notebook stamping to enhance user experience while maintaining security.

We’ll also give you a sneak peek into the upcoming Livebook Teams product, designed to streamline the experience of using Livebook within a team.

Let’s dive in and discover how these features can improve your workflow and secure your notebooks!

What’s wrong with computational notebooks?

Throughout the development of Livebook, one of the sources that informed our roadmap was a paper published in 2020 called “What’s Wrong with Computational Notebooks? Pain Points, Needs, and Design Opportunities”. The paper shows that computational notebook users face numerous pain points while using that kind of tool. One of those problems is security.

The paper defines that problem as follows:

Maintaining data confidentiality and access control is an ad hoc, manual process where errors can leak private client data

Here’s a quote about that problem by one of the people interviewed by the researchers:

We are missing a more private way of handling credentials. I don’t want client credentials be visible to others

To address that pain point, we added built-in secret management to Livebook since version 0.7.

Livebook’s built-in secret management allows your notebook to use sensitive data without hardcoding it. For example, imagine your notebook needs to use a password-protected API; this is how you’d save that password using Livebook Secrets from version 0.7:

As you create more and more notebooks and more secrets, you’ll eventually want to see all the secrets you created. But before Livebook 0.9, the only way to see all the secrets you configured was inside a notebook.

Now, we have a better way.

Livebook Hubs

This new Livebook release introduces a concept we’re calling Hubs.

Every new Livebook installation comes with a default personal Hub. This is the place where Livebook will save your secrets and where you can manage all of them. Let’s see how it works.

But a Hub is not only a place to centralize your secrets. When you visit your personal Hub, you’ll notice another section called Stamping.

Notebook stamping

Before explaining this feature, let’s discuss why we created it.

Imagine the following scenario. You have a secret in your Livebook called “API_PASSWORD.” If you download a notebook from the internet, you don’t want that secret to be accessible by that notebook by default. That’s why you must explicitly share a Livebook secret with a notebook.

But what if you were opening a notebook you created and had already shared secrets with that notebook? Although you already trust that notebook, Livebook would still make you explicitly share secrets with it every single time you open it. Let’s watch a video that illustrates that UX problem:

Enters notebook stamping.

Livebook 0.9 automatically stamps your notebooks so you don’t need to share a secret more than once with a notebook you trust. The notebook stamp contains the list of the secret names you explicitly shared with the notebook, and it’s encrypted using your secret key saved in your personal Hub.

Let’s see a video of how that new feature improves the UX of Livebook Secrets.

We also use the notebook source itself to generate the stamp, so someone can’t get your stamp and go stamping other notebooks, pretending it’s yours.

Since the stamping uses the secret key saved in your personal Hub, if you’re using Livebook on multiple machines and want to share notebooks between them, you can configure them with the same secret key.

With this update to Livebook’s security capabilities, we aim to ensure users can enjoy a secure working environment without compromising on ease of use.

But there’s still one problem left. What if you’re working in a team and you want to share secrets among team members? You don’t want to share your personal secret key; it’s yours. Enters Livebook Teams.

Livebook Teams

Livebook Teams is a paid product we’re developing that will streamline the experience of using Livebook within a team.

Livebook Teams is not a different version of Livebook. Instead, it is a Hub that all of your team members and colleagues connect to in order to work together.

It will manage all the Livebook Secrets shared by your team and be responsible for stamping all the notebooks that belong to your group, so you can safely share secrets and notebooks among team members.

We have a lot of features planned for Livebook Teams, it’s not only about security and secret management. It will also enable your team to:

• deploy notebooks inside your company
• schedule and audit notebook execution
• authentication and authorization of team members

And there’s a lot more coming!

If using Livebook inside your company sounds interesting to you, please submit our form to help us to inform our roadmap and get updates about it.

What now?

We encourage you to go ahead and install Livebook’s latest version so you can have a better user experience while maintaining the security of your notebooks.

And if you have any comments or want to share what you’ve built using Livebook, you can tweet using the #LivebookLaunchWeek hashtag.

Stay tuned for the following announcement of the Livebook Launch Week!

More Launch Week

• Day 1: Deploy notebooks as apps & quality-of-life upgrades
• Day 2: Distributed² Machine Learning notebooks with Elixir and Livebook
• Day 4: Build and deploy a Whisper chat app to Hugging Face in 15 minutes
• Day 5: Data wrangling in Elixir with Explorer, the power of Rust, the elegance of R

Welcome to the second day of Livebook Launch Week! 🎉

Today we will discuss all the new Machine Learning capabilities in Elixir and Livebook. First, we will discuss some of the new Neural Network tasks in Livebook v0.9. Then we will show how easy it is to make an existing model run concurrently and then distributed across multiple machines and multiple GPUs.

Let’s get started!

Distributed² Machine Learning with Elixir

This new Livebook release has many new Machine Learning models you can use with just a few clicks. But there is more exciting news about the Machine Learning story in the Elixir world.

Not only can you do Machine Learning with Elixir, but you can also do Distributed² Machine Learning!

But what does that “Distributed²” means?

It means that when executing a Machine Learning model with Elixir’s Nx, the distribution can happen on two dimensions:

• it can be distributed to multiple machines
• inside each machine, it can be distributed to multiple GPUs

This can lead to increased performance and better utilization of your hardware resources. And it only takes very few changes to your code.

Do you want to see an example? Watch this part of our video.

We are very excited about these features because we are starting to marry the benefits of Nx with the capabilities for building fault-tolerant and distributed software from the Erlang Virtual Machine. Case in point: adding distribution support to Nx took only 400 lines of code, including docs and tests!

New Machine Learning models available

Neural network tasks were initially added to Livebook version 0.8 with the idea of giving you the power to use modern Machine Learning models with just a few clicks.

This 0.9 release comes with more models. Here they are.

Speech-to-text

Conversation

Question answering

Language detection

Zero-shot text classification

Punctuation

What now?

We encourage you to go ahead and install Livebook’s latest version to start playing with all of those Machine Learning models!

And if you have any comments or want to share what you’ve built using Livebook, you can tweet using the #LivebookLaunchWeek hashtag.

Stay tuned for the following announcement of the Livebook Launch Week!

More Launch Week

• Day 1: Deploy notebooks as apps & quality-of-life upgrades
• Day 3: Hubs and secret management
• Day 4: Build and deploy a Whisper chat app to Hugging Face in 15 minutes
• Day 5: Data wrangling in Elixir with Explorer, the power of Rust, the elegance of R

Welcome to the first-ever Livebook Launch Week! 🎉

We’re kicking off this series of announcements to unveil the fantastic new features available in Livebook 0.9. Starting today, each day of this week, we’ll announce a new feature or something new you can do with this new Livebook release, version 0.9.

And today, we’re thrilled to announce the most prominent feature of this new release, the ability to run your notebook as an app.

Deploy Livebook notebooks as apps

Although Livebook is terrific for many use cases where you need to use it just by yourself, we always believed it could shine in contexts where multiple people are collaborating through it.

When Livebook was launched, it already came with real-time collaboration, allowing multiple people to edit a notebook simultaneously. This was already one step ahead of the traditional concept of a code notebook. But we thought it could go even further.

There are some scenarios where you want people to use your notebook but not necessarily edit it. In those scenarios, the person wants to run and interact with your notebook. That’s why we created and evolved Kino, a tool that enables you to build interactive notebooks.

Although Kino made your notebook interactive, it still felt like a notebook. The person could still see all the code cells mixed with the interactive widgets and the outputs. And this is not the best UX for sharing your notebook with people that need to use it but not edit it.

But now, we have a better way.

Now, you can deploy your notebook as an app! 🎉

This is a way to turn your Livebook notebook into a user-friendly application!

A deployed notebook is a web app that only shows the inputs and outputs of your notebook and is powered by your notebook code.

This allows you to share your notebook with a broader audience, making it more accessible to non-technical users or those unfamiliar with Livebook.

You can build internal apps, a demo of a Machine Learning model, or interactive automation tasks.

But in truth, we can’t imagine all the different ways you will use that, and we can’t wait to see what you will build with this new feature!

To get started, inside the Livebook’s Learn section, there’s a new notebook that will teach you how to write and deploy your first app: a chat application in only 15 lines of code!

Quality-of-life improvements

Star a notebook

This is for all of us who need to open a notebook multiple times per day or week and want to avoid repeatedly navigating the whole file directory structure to open that notebook every single time. Not anymore!

Now, you can star a notebook, and starred notebooks will show in your Livebook’s Home.

Shout out to ByeongUk Choi for adding that feature as a community contributor.

Recent notebooks

We revamped the “Opening a notebook” user flow.

Now all the ways of opening a notebook are centralized. And in that “Open notebook” page, we added a new section: “Recent notebooks.”

This section lists all the latest notebooks you’ve been working on, making it very easy to find recently used notebooks and quickly resume what you have been doing with Livebook since the last time you opened it.

Shout out to ByeongUk Choi for adding that feature as a community contributor.

Collapse sections

Finding a specific section within your notebook can take more than a single mouse scroll when your notebook gets large.

The new “collapse sections” feature lets you toggle the visibility of the cells of sections so you can focus on particular parts of the notebook you’re working on.

Shout out to Jannik Becher for adding that feature as a community contributor.

What now?

We encourage you to go ahead and install Livebook’s latest version to build and deploy your first Livebook app!

And if you have any comments or want to share what you’ve built using Livebook, you can tweet using the #LivebookLaunchWeek hashtag.

Stay tuned for the following announcement of the Livebook Launch Week!

More Launch Week

• Day 2: Distributed² Machine Learning notebooks with Elixir and Livebook
• Day 3: Hubs and secret management
• Day 4: Build and deploy a Whisper chat app to Hugging Face in 15 minutes
• Day 5: Data wrangling in Elixir with Explorer, the power of Rust, the elegance of R

We are thrilled to announce the latest release of Livebook, version 0.9! 🎉

A lot of work went into bringing you a host of new features that will make your experience with Livebook even better and enable Livebook to be used in many different ways.

Over the coming weeks, we will be sharing more information about these exciting new additions.

Meanwhile, you are welcome to update to the latest and greatest.

Keep in mind we have moved our containers to GitHub, so if you are using Docker for installing Livebook, make sure to upgrade image references from "livebook/livebook" to "ghcr.io/livebook-dev/livebook."

Stay tuned for more updates!

We are thrilled to introduce Livebook on Hugging Face Spaces! 🎉

Each Hugging Face Space environment offers up to 16GB of RAM and 2 CPU cores for free.

If you’re unfamiliar with Hugging Face (HF), it’s a platform for building, sharing, and collaborating on machine learning applications.

This is our second integration with Hugging Face; the first was through Bumblebee, which brings pre-trained neural network models from Hugging Face to the Elixir community.

We’ve been collaborating with HF to make using Livebook on Spaces a breeze. If you have a Hugging Face account, simply click the one-click deployment button below:

Alternatively, follow the step-by-step tutorial to install Livebook in a Hugging Face Space.

Livebook with GPU acceleration on Hugging Face Spaces

One of the great features of HF Spaces is its ease of upgrading to hardware with GPU accelerators. This is particularly useful for Machine Learning applications, which can be highly parallelized and computationally intensive.

Check out this video to see how easy it is to run Stable Diffusion with Livebook on top of a Hugging Face Space powered by a GPU:

Ready to give it a try for yourself? Start experimenting with Livebook on Hugging Face Spaces now.

In this blog post, we'll take a look at some of the new features released with Livebook 0.8.1. Let's dive in!

The new file input

One of the goals of Livebook is to enable you to build interactive notebooks. That means offering various input elements that allow users to input data into the notebook.

This new version comes with two new inputs, one of them is the file input. You can use it to allow the user of your notebook to upload a file that the notebook will process.

There are many scenarios where this can be useful, for example, data exploration. Let's see how the new input can be used to explore data in a CSV file.

The new audio input

Another new input available in this release is the audio input.

It provides two options for uploading audio data: recording using a microphone or uploading an audio file.

Let's see an example of this new input in action.

Support for capturing images from the camera in the image input

The image input was first introduced in Livebook 0.8.0. With this new release, it has been improved to include the ability to take a picture using the computer's camera, in addition to uploading an image file.

Let's see how it works.

This feature was contributed by Cocoa Xu. 

Option to run the Setup cell without cache

A new option has been added to run the setup cell without cache. This can be useful when you want to force the dependencies of your notebook to be installed again from scratch.

While this was previously possible through the :force option of Mix.install/2:

Mix.install(
    [
        {:kino, "~> 0.8.1"}
    ],
    force: true
)

With this new release, it's now as simple as clicking a button:

Loading LB_ environment variables as Livebook secrets

Secrets management is a feature that was added in Livebook 0.7. It allows you to securely handle sensitive data, such as passwords and API keys.

Before this release, the UI was the only way to add secrets to Livebook. But now, there's another way.

You can provision Livebook Secrets through environment variables on the machine running your Livebook instance. Just create environment variables starting with LB_, such as LB_API_KEY or LB_DATABASE_PASSWORD, and Livebook will load them as Secrets.

This can be especially useful when running Livebook on platforms like Fly.io and Hugging Face. This means you can set up secrets on their panels, and they will directly appear in Livebook.

Let's see how that works for running Livebook via Docker.

Docker images with CUDA libraries

Last but not least, we also started to distribute Livebook via Docker images with CUDA libraries installed.

CUDA is a parallel computing platform and API that allows software to take advantage of the power of GPUs. This is particularly useful in technical fields where parallel programming can be applied, such as Machine Learning (ML).

Now running Stable Diffusion on your GPU directly from Livebook is even easier!

Try it!

To play with the new features, all you need to do is:

• Install the new Livebook version
• Import the notebook containing a demo of the new features by clicking on the badge below

Happy hacking!

Livebook 0.8 was launched a few weeks ago, and the highlight of that release was the new Neural Network Smart cell. But there are many other exciting updates included as well.

In this blog post, we will showcase ten of the most noteworthy features released with Livebook 0.8.

New mechanism for tracking how cells depend on each other

A known pain point of computational notebooks is reproducibility. But Livebook already solved that by enabling truly reproducible workflows. This was accomplished by the fact that the Livebook execution model is fully sequential, and there is no global mutable state.

Still, there was a downside with that fully sequential model. Whenever a cell was evaluated, all subsequent cells were marked as stale and required reevaluation. That happened regardless of whether those cells depended on the evaluated cell.

Not anymore!

This new release now tracks how cells depend on each other and only marks subsequent cells as stale if necessary. Let's see how that works.

Let's say you have four code cells like that:

Look how cell 4 depends on cell 1 and cell 2, but doesn't depend on cell 3. And notice how cell 4 simulates a computation that takes some time to finish.

Before Livebook 0.8, if you changed cell 3, cell 4 would become stale, even though cell 4 didn't depend on cell 3. And you'd need to reevaluate it:

With Livebook 0.8, when you change cell 3, Livebook knows that although cell 4 is subsequent to cell 3, it doesn't depend on it, so it doesn't mark cell 4 as stale anymore:

No more need to waste time waiting for unnecessary cell reevaluation!

Automatic execution of doctests

One cool feature of Elixir is Doctests. It helps you ensure that your documentation is up to date with your code.

This new release integrates Doctests natively into Livebook.

Now, whenever you evaluate a cell that contains a module definition with doctests, Livebook will automatically run those doctests for you and will show you the output:

We're planning to streamline that workflow even more in future releases.

Render math in on-hover documentation

Elixir has an amazing developer experience when it comes to documentation. And Livebook aims to leverage that.

Before this new release, Livebook already supported seeing the documentation of a module or function when you hover over it:

Now, the on-hover documentation also supports those fancy math documentation of yours (based on KaTeX)

View and delete secrets in the sidebar

Livebook 0.7 introduced secret management. A solution to help you manage sensitive data used by your notebooks, like passwords and API keys.

With this new release, you can also view and delete those secrets in the notebook sidebar:

Support for image input

Livebook enables you to add a variety of user inputs to your notebooks, making them interactive and parametrizable.

This new release comes with a new input that allows the user of your notebook to upload images:

Visualization of nested data as a tree view

Inspecting a nested data structure can be hard when it gets big. For example, when you want to check the result of an HTTP API call.

With Kino 0.8 that accompanies the Livebook release, you can now visualize and inspect nested data in a tree view, so it gets easier to understand it:

This was a community contribution by Stefan Chrobot. He started the project during Spawnfest and won 2nd place overall. Shout out to him!

Neural Network Smart cell

We discussed that new feature in detail in a previous post. But it's so cool that we thought it was worth mentioning it again here.

That new Smart cell allows you to run various machine learning models directly in Livebook with just a few clicks. Here's an example of a text classification model:

Slack Message Smart cell

Let's say you want to send a notification to your Slack after your notebook completes some automation.

With the new Slack Smart cell, that's dead easy:

Geocoding in Map Smart cell

The Map Smart cell got even better. Now besides accepting data as latitude and longitude, you can also use the names of countries, states, cities, counties, and streets.

Let's see how that works:

More options to configure charts with the Chart Smart Cell

We added new options to help you customize your charts even more.

You can now toggle the bin config to discretize numeric values into a set of bins. This is useful for creating histograms, for example. Here's how it works:

Another new option is the color scheme. You can now choose your chart's color from a set of named color palettes. Here's how it works:

Last but not least, let's check the new scale config. You can use it to change the scale type of your chart, for example, from a linear to a log scale. Let's see how it works:

Try it!

To play with the new features, all you need to do is:

• Install the new Livebook version
• Import a notebook containing a demo of the new features by clicking on the badge below

Happy hacking!

We are glad to announce a variety of Neural Networks models are now available to the Elixir community via the Bumblebee project.

We have implemented several models, from GPT2 to Stable Diffusion, in pure Elixir, and you can download training parameters for said models directly from Hugging Face.

To run your first Machine Learning model in Elixir, all you need is three clicks, thanks to our integration between Livebook and Bumblebee. You can also easily embed and run said models within existing Elixir projects.

Watch the video by José Valim covering all of these topics and features:

Running Machine Learning models with Livebook

Here are some examples of what it looks like to use Livebook to run Machine Learning models:

Text to image

Image classification

Text classification

Text generation

Incorporating models into any Elixir project

Thanks to the new Nx.Serving functionality, you should be able to incorporate those models into any existing project with little effort and run them at scale.

You should be able to embed and serve these models as part of your existing Phoenix web applications, integrate them into data processing pipelines with Broadway, and deploy them alongside Nerves embedded systems - without needing 3rd-party dependencies.

Here’s an example of using Bumblebee to run an image classification model inside a Phoenix app:

Integration with Hugging Face

Bumblebee allows you to download and use trained models directly from Hugging Face. Let’s see an example of how we can generate text continuation using the popular GPT-2 model:

{:ok, gpt2} = Bumblebee.load_model({:hf, "gpt2"})
{:ok, tokenizer} = Bumblebee.load_tokenizer({:hf, "gpt2"})

serving = Bumblebee.Text.generation(gpt2, tokenizer, max_new_tokens: 10)

text = "Yesterday, I was reading a book and"
Nx.Serving.run(serving, text)

#=> %{
#=>    results: [
#=>        %{
#=>            text: "Yesterday I was reading a book and I was thinking, 'What's going on?'"
#=>        }
#=>    ]
#=> }

Compiling to CPU/GPU

All of our Neural Networks can be compiled to the CPU/GPU, thanks to projects such as EXLA (based on Google XLA) and Torchx (based on Libtorch).

A massive milestone in our Numerical Elixir effort

This release is a huge milestone in our Numerical Elixir effort, which started almost two years ago. These new features, in particular, are possible thanks to the enormous efforts of José Valim, Jonatan Kłosko, Sean Moriarity, and Paulo Valente. We are also thankful to Hugging Face for enabling collaborative Machine Learning across communities and tools, which played an essential role in bringing the Elixir ecosystem up to speed.

Next, we plan to focus on training and transfer learning of Neural Networks in Elixir, allowing developers to augment and specialize pre-trained models according to the needs of their businesses and applications. We also hope to publish more on our progress in developing traditional Machine Learning algorithms.

Your turn

If you want to give Bumblebee a try, you can:

• Download Livebook v0.8 and automatically generate “Neural Networks tasks” from the “+ Smart” cell menu inside your notebooks.
• We have also written single-file Phoenix applications as examples of Bumblebee models inside Phoenix (+ LiveView) apps. Those should provide the necessary building blocks to integrate Bumblebee into your production app.
• For a more hands-on approach, read some of our notebooks.

If you want to help us build the Machine Learning ecosystem for Elixir, check out the projects above, and give them a try. There are many exciting areas, from compiler development to model building. For instance, pull requests that bring more models and architectures to Bumblebee are welcome. The future is concurrent, distributed, and fun!