Perhaps "Don't change your API to something incompatible but with the same names" would be a good piece of guidance too?
https://github.com/fchollet/keras/issues/3921#issuecomment-3...
In User experience design for APIskeras-team
keras
Python2015–2026
keras-team / keras
keras
Deep Learning for humans
36Distinct people
56Mentions
1Explicit recommenders
64.4KGitHub stars
What to know before exploring
What it is
Deep Learning for humans
GitHub
Where it is used
No documented product use was verified in the last source check.
What people are saying
If people are interested in getting started with question answering on the bAbi dataset, I wrote a baseline RNN example that's now in Keras[1]. Whilst I love the theory behind…
Smerity used a recommendation phrase. One indexed comment matches. This is a phrase match, not a verdict.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
No other repository is repeatedly linked in the same discussions.
This week on Hacker News
Nov 8–Nov 15 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/15/2026, 12:03:30 PM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year56 dated mentions
Observed mentions: 2015-03-28 22:59:03 UTC to 2026-08-07 17:09:43 UTC.
* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 10 | 4 | 6 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 7 | 1 | 6 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 20 | 1 | 19 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 8 | 3 | 5 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 3 | 1 | 2 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 2 | 1 | 1 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 1 | 1 | 0 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2026 (partial) | 2026-01-01 00:00:00 UTC | 2027-01-01 00:00:00 UTC | 1 | 1 | 0 |
From the project README
An excerpt from the repository, fetched Nov 13, 2026.
Read the project’s introduction
Keras 3: Deep Learning for Humans
Keras 3 is a multi-backend deep learning framework, with support for JAX, TensorFlow, PyTorch, and OpenVINO (for inference-only).
Effortlessly build and train models for computer vision, natural language processing, audio processing,
timeseries forecasting, recommender systems, etc.
Accelerated model development: Ship deep learning solutions faster thanks to the high-level UX of Keras
and the availability of easy-to-debug runtimes like PyTorch or JAX eager execution.
State-of-the-art performance: By picking the backend that is the fastest for your model architecture (often JAX!),
leverage speedups ranging from 20% to 350% compared to other frameworks. Benchmark here.
Datacenter-scale training: Scale confidently from your laptop to large clusters of GPUs or TPUs.
Join nearly three million developers, from burgeoning startups to global enterprises, in harnessing the power of Keras 3.
Installation
Install with pip
Keras 3 is available on PyPI as keras. Note that Keras 2 remains available as the tf-keras package.
Install keras:
pip install keras --upgrade
Install backend package(s).
To use keras, you should also install the backend of choice: tensorflow, jax, or torch. Additionally,
The openvino backend is available with support for model inference only.
(Optional) Install remote file access support.
To save to and load from Google Cloud Storage (gs:// paths) without TensorFlow, install the gcs extra:
pip install "keras[gcs]"
Local installation
Minimal installation
Keras 3 is compatible with Linux and macOS systems. For Windows users, we recommend using WSL2 to run Keras.
To install a local development version:
Install dependencies:
pip install -r requirements.txt
Run installation command from the root directory.
python pip_build.py --install
Run API generation script when creating PRs that update keras_export public APIs:
./shell/api_gen.sh
Backend Compatibility Table
The following table lists the minimum supported versions of each backend for the latest stable release of Keras (v3.x):
Backend
Minimum Supported Version
TensorFlow
2.16.1
JAX
0.4.20
PyTorch
2.6.0
OpenVINO
2026.2.0
Adding GPU support
The requirements.txt file will install a CPU-only version of TensorFlow, JAX, and PyTorch. For GPU support, we also
provide a separate requirements-{backend}-cuda.txt for TensorFlow, JAX, and PyTorch. These install all CUDA
dependencies via pip and expect a NVIDIA driver to be pre-installed. We recommend a clean Python environment for each
backend to avoid CUDA version mismatches. As an example, here is how to create a JAX GPU environment with conda:
conda create -y -n keras-jax python=3.10
conda activate keras-jax
pip install -r requirements-jax-cuda.txt
python pip_build.py --install
Configuring your backend
You can export the environment variable KERAS_BACKEND or you can edit your local config file at ~/.keras/keras.json
to configure your backend. Available backend options are: "tensorflow", "jax", "torch", "openvino". Example:
export KERAS_BACKEND="jax"
In Colab, you can do:
import os
os.environ["KERAS_BACKEND"] = "jax"
import keras
Note: The backend must be configured before importing keras, and the backend cannot be changed after
the package has been imported.
Note: The OpenVINO backend is an inference-only backend, meaning it is designed only for running model
predictions using model.predict() method.
Backwards compatibility
Keras 3 is intended to work as a drop-in replacement for tf.keras (when using the TensorFlow backend). Just take your
existing tf.keras code, make sure that your calls to model.save() are using the up-to-date .keras format, and you're
done.
If your tf.keras model does not include custom components, you can start running it on top of JAX or PyTorch immediately.
If it does include custom components (e.g. custom layers or a custom train_step()), it is usually possible to convert it
to a backend-agnostic implementation in just a few minutes.
In addition, Keras models can consume datasets in any format, regardless of the backend you're using:
you can train your models with your existing tf.data.Dataset pipelines or PyTorch DataLoaders.
Why use Keras 3?
Run your high-level Keras workflows on top of any framework -- benefiting at will from the advantages of each framework,
e.g. the scalability and performance of JAX or the production ecosystem options of TensorFlow.
Write custom components (e.g. layers, models, metrics) that you can use in low-level workflows in any framework.
You can take a Keras model and train it in a training loop written from scratch in native TF, JAX, or PyTorch.
You can take a Keras model and use it as part of a PyTorch-native Module or as part of a JAX-native model function.
Make your ML code future-proof by avoiding framework lock-in.
As a PyTorch user: get access to power and usability of Keras, at last!
As a JAX user: get access to a fully-featured, battle-tested, well-documented modeling and training library.
Read more in the Keras 3 release announcement.
Read the full README on GitHubWhat Hacker News says
20 sourcesHa very nice!
I made a vary similar (but much rougher around the edges) project for fun a few months ago using a smaller french corpus of press releases from La Quadrature du Net (a non-profit lobbying for net neutrality in France and Europe).
There is a live demo at http://jorquera.net/quadra_neural/. You can press tab to auto-complete word-by-word, or just start typing and the suggestions update on the fly. Instead of "Weirdness" I called my cursor "Drunkenness" :)
I used keras-js (https://github.com/transcranial/keras-js) to run my model in the browser.
If you are interested in this kind of experiments, do go for it! It's quite accessible, and projects of this scale do not require heavy hardware (I generated my models using a GTX 770).
If you need a kickstart, in addition to the repo from the OP all the code for my project is Free Sof
Read the rest
tware (https://github.com/tomjorquera/quadra_neural), and I tried to document the generation process in a jupyter notepad https://github.com/tomjorquera/quadra_neural/blob/master/gen.... While I did it on a french corpus, it should work with any language.
I used two main resources for inspiration :
- http://karpathy.github.io/2015/05/21/rnn-effectiveness/
- https://github.com/fchollet/keras/blob/master/examples/lstm_...
I'm pretty sure this is actually pretrained as a few shot learning model under the hood, so that's a bit hard. For the camera part at least:
http://opencv-python-tutroals.readthedocs.io/en/latest/py_tu...
and you could do worse then this https://github.com/fchollet/keras/blob/master/examples/mnist...
In Teachable Machine: Teach a machine using your camera, live in the browserIn the PR he is very supportive of the addition of CNTK: https://github.com/fchollet/keras/pull/6800
In Benchmarking CNTK on Keras: Is It Better at Deep Learning Than TensorFlow?The important feature is Keras compatability (although it doesn't seem to be in the official repo yet: https://github.com/fchollet/keras/pull/6800)
In terms of "how is CNTK better than TensorFlow," CNTK trains 5-10x faster at minimum on pre-2.0 LSTM benchmarks, which is big since LSTMs are used for a lot nowadays. (https://arxiv.org/abs/1608.07249)
In Microsoft Cognitive Toolkit 2.0The important feature is Keras compatability: https://docs.microsoft.com/en-us/cognitive-toolkit/Using-CNT... (although it doesn't seem to be in the official repo yet: https://github.com/fchollet/keras/pull/6800)
In terms of "how is CNTK better than TensorFlow," CNTK performs 6x better at minimum on old LSTM benchmarks, which is big. (https://arxiv.org/abs/1608.07249)
In Microsoft releases version 2.0 of its deep learning toolkitA note: looking at the code, this isn't a seq2seq Keras model. The core model code is a fork of the base Keras text generation example (https://github.com/fchollet/keras/blob/master/examples/lstm_...), which works like a char-rnn where the previous 80 characters will predict the 81st character, then feed the generated characters back into the model. In the server implementation, the server keeps predicting characters until it hits a break character, which will then serve the generated characters to the user.
In a seq2seq implementation, you need to predict all output characters simultaneously (i.e. model input is all characters in a line, model output is all characters in the next line), which in Keras involves using a TimeDistributed(Dense()) layer. (see the Keras example for seq2seq: https://github.com/fchollet/keras/blob/master/example
Read the rest
s/addit...) This also requires more sequence ETL and a lot more training time.
I don't want to diminish what they and other similar projects do and actually I'm not really familiar with FPGA development, but I have one thought: what if we don't need one more language, but rather something on a different level of abstraction?
The first neural networks that ran on GPU was written using low-level GPU primitives [1]. This was a non-trivial process that required to do a lot of low-level stuff. It required system programming skills and time to implement new architectures. But a group of researchers at the University of Montreal developed Theano [2], a framework that allows you to define computational graphs in Python programming language and then compile them to CUDA code that could be then executed on GPU. Instead of spending resources on development of a new language they put their efforts on actual thinking out useful
Read the rest
abstractions and implementing compiler that works efficiently. It is also notable that they didn't include very high level abstraction in Theano too, but there are libraries like Lasagne [3] and Keras [4] that introduced higher level abstractions (neural network layers and pluggable pre-implemented models) on top of Theano. It is safe to say that Theano boosted Deep Learning research, making programming of new neural networks architectures quicker and accessible.
What if actually we need just the same thing for FPGA? Just a Python library that defines useful abstractions for logic circuits building, allows to construct arbitrary graphs using them, and then compile these graphs to VHDL. Assuming that the basic building blocks defined in Python are well defined and tested, it would be easy to implement verification and some testing in pure Python, the tooling like visualising logic diagrams can be implemented in pure Python too.
In addition to reduced efforts for development (because you don't need to design and implement a new language), it would be easier to pick up by software programmers: they would not need to learn new syntax, but concentrate on core conceptions like gates/summators/other stuff and graphs involiving them. It wouldn't be necessary to develop special-purpose editors, because it just Python, and again, because the tests for the resulting schemas could be written and ran in pure Python, it would be possible to use standard CI tools like Travis for open source development.
Edit: It seems like there is already a project MyHDL [5] that does something very close to what I described above.
[1] https://hal.inria.fr/inria-00112631/en/
[2] https://github.com/Theano/Theano
[3] https://github.com/Lasagne/Lasagne
[4] https://github.com/fchollet/keras
[5] http://www.myhdl.org/
> Is it better to learn Keras instead of tflearn?
Go with Keras. I believe this recent release was partially motivated by Google deciding to fold Keras into tensorflow. Therefore, I would expect keras to supersede tflearn in the areas where they overlap.
https://github.com/fchollet/keras/issues/5050
In Introducing Keras 2See the release notes: https://github.com/fchollet/keras/wiki/Keras-2.0-release-not...
- You can use a Keras model to compute some tensor(s), turn that into a loss, and manually add that loss to the model via `add_loss` (it just needs to only depend on the model's inputs).
- Not all of your model outputs have to have a loss associated with them. So you can do both {input, output}->loss and input->output in your workflow, as you wish. Effectively, losses and outputs are decoupled.
The VAE example hasn't yet been updated to use the `add_loss` feature, but it should be.
In Introducing Keras 21. Still no support for multiple losses. Models like VAEs cannot be idiomatically implemented. The second loss has to be 'hacked' in. Notice how in the official example for VAE, the kl_loss is computed using variables which are NOT available via the loss function (https://github.com/fchollet/keras/blob/master/examples/varia...)
2. It's still an input->output paradigm, rather than a {input, output}->loss paradigm which gives more flexibility.
These two issues are the main reason why I stick to slightly lower level APIs, even though I _want_ to use Keras.
In Introducing Keras 2It's trivial with 'max' merge param: https://github.com/fchollet/keras/pull/3128
In Introducing Keras 2Will Keras2 support PyTorch as backend, in the future?
Answer: [0]
No, there are no plans to support PyTorch. There is nothing to be gained in supporting every novelty framework that crops up every quarter. Our goal is to make deep learning accessible and useful to as many people as possible, and that goal is completely opposite to building up deep learning hipster cred.
[0]: https://github.com/fchollet/keras/issues/5299
In Introducing Keras 2Showing the 15 most recent of 20 sources. Enable JavaScript to search and browse every indexed mention.