Update changelog (#1476)

doc/source/changelog.md

@@ -1,16 +1,54 @@
 # Changelog
 
-## Unreleased
+## v1.1.0 (2022-10-31)
 
-- **Log** `Client` **exceptions in Virtual Client Engine**
+- **Introduce Differential Privacy wrappers (preview)** ([#1357](https://github.com/adap/flower/pull/1357), [#1460](https://github.com/adap/flower/pull/1460))
 
-  All `Client` exceptions happening in the VCE will now be logged by default and not just exposed through the strategies.
+  The first (experimental) preview of pluggable Differential Privacy wrappers enables easy configuration and usage of differential privacy (DP). The pluggbale DP wrappers enable framework-agnostic **and** strategy-agnostic usage of both client-side DP and server-side DP. Head over to the Flower docs, a new explainer goes into more detail.
+
+- **New iOS CoreML code example** ([#1289](https://github.com/adap/flower/pull/1289))
+
+  Flower goes iOS! A massive new code example shows how Flower clients can be built for iOS. The code example contains both Flower iOS SDK components that can be used for many tasks, and one task example running on CoreML.
+
+- **New FedMedian strategy** ([#1461](https://github.com/adap/flower/pull/1461))
+
+  The new `FedMedian` strategy implements Federated Median (FedMedian) by [Yin et al., 2018](https://arxiv.org/pdf/1803.01498v1.pdf).
+
+- **Log** `Client` **exceptions in Virtual Client Engine** ([#1493](https://github.com/adap/flower/pull/1493))
+
+  All `Client` exceptions happening in the VCE are now logged by default and not just exposed to the configured `Strategy` (via the `failures` argument).
+
+- **Improve Virtual Client Engine internals** ([#1401](https://github.com/adap/flower/pull/1401), [#1453](https://github.com/adap/flower/pull/1453))
+
+  Some internals of the Virtual Client Engine have been revamped. The VCE now uses Ray 2.0 under the hood, the value type of the `client_resources` dictionary changed to `float` to allow fractions of resources to be allocated.
 
 - **Support optional** `Client`**/**`NumPyClient` **methods in Virtual Client Engine**
 
+  The Virtual Client Engine now has full support for optional `Client` (and `NumPyClient`) methods.
+
 - **Provide type information to packages using** `flwr` ([#1377](https://github.com/adap/flower/pull/1377))
 
-  The package `flwr` is now bundled with a `py.typed` file indicating that the package is typed. This enables typing support for projects or packages that use `flwr` by enabling them to type-check their code using tool like `mypy`.
+  The package `flwr` is now bundled with a `py.typed` file indicating that the package is typed. This enables typing support for projects or packages that use `flwr` by enabling them to improve their code using static type checkers like `mypy`.
+
+- **Updated code example** ([#1344](https://github.com/adap/flower/pull/1344), [#1347](https://github.com/adap/flower/pull/1347))
+
+  The code examples covering scikit-learn and PyTorch Lightning have been updated to work with the latest version of Flower.
+
+- **Updated documentation** ([#1355](https://github.com/adap/flower/pull/1355), [#1558](https://github.com/adap/flower/pull/1558), [#1379](https://github.com/adap/flower/pull/1379), [#1380](https://github.com/adap/flower/pull/1380), [#1381](https://github.com/adap/flower/pull/1381), [#1332](https://github.com/adap/flower/pull/1332), [#1391](https://github.com/adap/flower/pull/1391), [#1403](https://github.com/adap/flower/pull/1403), [#1364](https://github.com/adap/flower/pull/1364), [#1409](https://github.com/adap/flower/pull/1409), [#1419](https://github.com/adap/flower/pull/1419), [#1444](https://github.com/adap/flower/pull/1444), [#1448](https://github.com/adap/flower/pull/1448), [#1417](https://github.com/adap/flower/pull/1417), [#1449](https://github.com/adap/flower/pull/1449), [#1465](https://github.com/adap/flower/pull/1465), [#1467](https://github.com/adap/flower/pull/1467))
+
+  There have been so many documentation updates that it doesn't even make sense to list them individually.
+
+- **Restructured documentation** ([#1387](https://github.com/adap/flower/pull/1387))
+
+  The documentation has been restructured to make it easier to navigate. This is just the first step in a larger effort to make the Flower documentation the best documentation of any project ever. Stay tuned!
+
+- **Open in Colab button** ([#1389](https://github.com/adap/flower/pull/1389))
+
+  The four parts of the Flower Federated Learning Tutorial now come with a new `Open in Colab` button. No need to install anything on your local machine, you can now use and learn about Flower in your browser, it's only a single click away.
+
+- **Improved tutorial** ([#1468](https://github.com/adap/flower/pull/1468), [#1470](https://github.com/adap/flower/pull/1470), [#1472](https://github.com/adap/flower/pull/1472), [#1473](https://github.com/adap/flower/pull/1473), [#1474](https://github.com/adap/flower/pull/1474), [#1475](https://github.com/adap/flower/pull/1475))
+
+  The Flower Federated Learning Tutorial has two brand-new parts covering custom strategies (still WIP) and the distinction between `Client` and `NumPyClient`. The existing parts one and two have also been improved (many small changes and fixes).
 
 ## v1.0.0 (2022-07-28)
 

doc/source/differential-privacy-wrappers.rst

@@ -3,6 +3,9 @@ Differential Privacy Wrappers in Flower
 
 Flower provides differential privacy (DP) wrapper classes for the easy integration of the central DP guarantees provided by DP-FedAvg into training pipelines defined in any of the various ML frameworks that Flower is compatible with. 
 
+.. warning::
+  Please note that these components are still experimental, the correct configuration of DP for a specific task is still an unsolved problem.
+
 .. note::
   The name DP-FedAvg is misleading since it can be applied on top of any FL algorithm that conforms to the general structure prescribed by the FedOpt family of algorithms.
 

doc/source/release-process.rst

@@ -3,12 +3,19 @@ Release Process
 
 This document describes the current release process. It may or may not change in the future.
 
-Process
--------
+Before the release
+------------------
+
+Update the changelog (``changelog.md``) with all relevant changes that happened after the last release. If the last release was tagged ``v1.0.0``, you can use the following URL to see all commits that got merged into ``main`` since then:
+
+`GitHub: Compare v1.0.0...main <https://github.com/adap/flower/compare/v1.0.0...main>`_
+
+During the release
+------------------
 
 The version number of a release is stated in ``pyproject.toml``. To release a new version of Flower, the following things need to happen (in that order):
 
-1. Update the ``changelog.rst`` section header ``Unreleased`` to contain the version number and date for the release you are building. Create a pull request with the change.
+1. Update the ``changelog.md`` section header ``Unreleased`` to contain the version number and date for the release you are building. Create a pull request with the change.
 2. Tag the release commit with the version number as soon as the PR is merged: ``git tag v0.12.3``, then ``git push --tags``
 3. Build the release with ``./dev/build.sh``, then publish it with ``./dev/publish.sh``
 4. Create an entry in GitHub releases with the release notes for the previously tagged commit and attach the build artifacts (:code:`.whl` and :code:`.tar.gz`).
@@ -20,7 +27,7 @@ Create a pull request which contains the following changes:
 
 1. Increase the minor version in ``pyproject.toml`` by one.
 2. Update all files which contain the current version number if necessary.
-3. Add a new ``Unreleased`` section in ``changelog.rst``.
+3. Add a new ``Unreleased`` section in ``changelog.md``.
 
 Merge the pull request on the same day (i.e., before a new nighly release gets published to PyPI).
 

doc/source/tutorial/Flower-2-Strategies-in-FL-PyTorch.ipynb

@@ -8,7 +8,9 @@
       "source": [
         "# Strategies in Federated Learning\n",
         "\n",
-        "Welcome to the next part of the federated learning tutorial. In this notebook, we'll begin to customize the federated learning system we built in the introductory notebook (again, using [Flower](https://flower.dev/) and [PyTorch](https://pytorch.org/)).\n",
+        "Welcome to the next part of the federated learning tutorial. In previous parts of this tutorial, we introduced federated learning with PyTorch and Flower ([part 1](https://flower.dev/docs/tutorial/Flower-1-Intro-to-FL-PyTorch.html)).\n",
+        "\n",
+        "In this notebook, we'll begin to customize the federated learning system we built in the introductory notebook (again, using [Flower](https://flower.dev/) and [PyTorch](https://pytorch.org/)).\n",
         "\n",
         "> Join the Flower community on Slack to connect, ask questions, and get help: [Join Slack](https://flower.dev/join-slack) 🌻 We'd love to hear from you in the `#introductions` channel! If anything is unclear, head over to the `#questions` channel.\n",
         "\n",

doc/source/tutorial/Flower-4-Client-and-NumPyClient-PyTorch.ipynb

@@ -6,9 +6,9 @@
         "id": "cz71fPGrpRiQ"
       },
       "source": [
-        "# Flower Client and NumPyClient\n",
+        "# Client and NumPyClient\n",
         "\n",
-        "Welcome to the fourth part of the Flower federated learning tutorial. In the previous parts of this tutorial, we introduced federated learning with PyTorch and Flower ([part 1](https://flower.dev/docs/tutorial/Flower-1-Intro-to-FL-PyTorch.html)), we learned how strategies can be used to customize the execution on both the server and the clients ([part 2](https://flower.dev/docs/tutorial/Flower-2-Strategies-in-FL-PyTorch.html)), and we built our own custom strategy from scratch (part 3 - WIP).\n",
+        "Welcome to the fourth part of the Flower federated learning tutorial. In the previous parts of this tutorial, we introduced federated learning with PyTorch and Flower ([part 1](https://flower.dev/docs/tutorial/Flower-1-Intro-to-FL-PyTorch.html)), we learned how strategies can be used to customize the execution on both the server and the clients ([part 2](https://flower.dev/docs/tutorial/Flower-2-Strategies-in-FL-PyTorch.html)), and we built our own custom strategy from scratch ([part 3 - WIP](https://flower.dev/docs/tutorial/Flower-3-Building-a-Strategy-PyTorch.html)).\n",
         "\n",
         "In this notebook, we revisit `NumPyClient` and introduce a new baseclass for building clients, simply named `Client`. In previous parts of this tutorial, we've based our client on `NumPyClient`, a convenience class which makes it easy to work with machine learning libraries that have good NumPy interoperability. With `Client`, we gain a lot of flexibility that we didn't have before, but we'll also have to do a few things the we didn't have to do before.\n",
         "\n",