diff --git a/conflictfree/length_model.py b/conflictfree/length_model.py index c21ed5c..905d189 100644 --- a/conflictfree/length_model.py +++ b/conflictfree/length_model.py @@ -70,6 +70,7 @@ def rescale_length( class ProjectionLength(LengthModel): """ Rescale the length of the target vector based on the projection of the gradients on the target vector: + $$ |\mathbf{g}_c|=\sum_{i=1}^m|\mathbf{g}_i|\mathcal{S}_c(\mathbf{g}_i,\mathbf{g}_c) $$ @@ -160,6 +161,7 @@ class TrackMinimum(_FlexibleTrackProjectionLength): """ Rescale the length of the target vector based on the projection of the gradients on the target vector. All the gradients will be rescaled to the same length as the minimum gradient before projection, i.e., the minimum gradient will be the same length as the target vector. + $$ |\mathbf{g}_c|=\sum_{i=1}^m|\mathbf{g}_{min}|\mathcal{S}_c(\mathbf{g}_i,\mathbf{g}_c) $$ @@ -176,6 +178,7 @@ class TrackMaximum(_FlexibleTrackProjectionLength): """ Rescale the length of the target vector based on the projection of the gradients on the target vector. All the gradients will be rescaled to the same length as the maximum gradient before projection, i.e., the maximum gradient will be the same length as the target vector. + $$ |\mathbf{g}_c|=\sum_{i=1}^m|\mathbf{g}_{max}|\mathcal{S}_c(\mathbf{g}_i,\mathbf{g}_c) $$ @@ -192,14 +195,18 @@ class TrackHarmonicAverage(_FlexibleTrackProjectionLength): """ Rescale the length of the target vector based on the projection of the gradients on the target vector. All the gradients will be rescaled to the harmonic average of the lengths of all gradients before projection, i.e., the minimum gradient will be the same length as the target vector. + $$ |\mathbf{g}_c|=\sum_{i=1}^m\overline{|\mathbf{g}|}_{harm}\mathcal{S}_c(\mathbf{g}_i,\mathbf{g}_c) $$ + where + $$ \overline{|\mathbf{g}|}_{harm}=\frac{m}{\sum_{i=1}^m \frac{1}{|\mathbf{g}_i|}} $$ - The harmonic average is used to avoid the influence of the large gradients. + + The harmonic average can be used to avoid the influence of the large gradients. """ def __init__(self): @@ -213,10 +220,13 @@ class TrackArithmeticAverage(_FlexibleTrackProjectionLength): """ Rescale the length of the target vector based on the projection of the gradients on the target vector. All the gradients will be rescaled to the arithmetic average of the lengths of all gradients before projection, i.e., the minimum gradient will be the same length as the target vector. + $$ |\mathbf{g}_c|=\sum_{i=1}^m\overline{|\mathbf{g}|}_{arith}\mathcal{S}_c(\mathbf{g}_i,\mathbf{g}_c) $$ + where + $$ \overline{|\mathbf{g}|}_{arith}=\frac{1}{m}\sum_{i=1}^m |\mathbf{g}_i| $$ @@ -233,14 +243,18 @@ class TrackGeometricAverage(_FlexibleTrackProjectionLength): """ Rescale the length of the target vector based on the projection of the gradients on the target vector. All the gradients will be rescaled to the geometric average of the lengths of all gradients before projection, i.e., the minimum gradient will be the same length as the target vector. + $$ |\mathbf{g}_c|=\sum_{i=1}^m\overline{|\mathbf{g}|}_{geom}\mathcal{S}_c(\mathbf{g}_i,\mathbf{g}_c) $$ + where + $$ \overline{|\mathbf{g}|}_{geom}=\left(\prod_{i=1}^m |\mathbf{g}_i|\right)^{\frac{1}{m}} $$ - The geometric average is used to avoid the influence of the large gradients. + + The geometric average can be used to avoid the influence of the large gradients. """ def __init__(self): @@ -255,6 +269,7 @@ class TrackSpecific(_FlexibleTrackProjectionLength): Rescale the length of the target vector based on the projection of the gradients on the target vector. All the gradients will be rescaled to the same length as the specific gradient before projection. E.g., if the track_id is 2, then all the gradients will be rescaled to the same length as the third gradient before projection. + $$ |\mathbf{g}_c|=\sum_{i=1}^m\overline{|\mathbf{g}|}_{track_id}\mathcal{S}_c(\mathbf{g}_i,\mathbf{g}_c) $$ diff --git a/docs/api/length_model.md b/docs/api/length_model.md index e0f8ca1..755ded1 100644 --- a/docs/api/length_model.md +++ b/docs/api/length_model.md @@ -3,6 +3,12 @@ The `ProjectionLength` class is the default length model for the ConFIG algorith ## Length Model ::: conflictfree.length_model.ProjectionLength +::: conflictfree.length_model.TrackMinimum +::: conflictfree.length_model.TrackMaximum +::: conflictfree.length_model.TrackHarmonicAverage +::: conflictfree.length_model.TrackArithmeticAverage +::: conflictfree.length_model.TrackGeometricAverage +::: conflictfree.length_model.TrackSpecific ## Base Class of Length Model ::: conflictfree.length_model.LengthModel \ No newline at end of file diff --git a/docs/assets/troubleshooting/difweightmodel.png b/docs/assets/troubleshooting/difweightmodel.png new file mode 100644 index 0000000..e43090c Binary files /dev/null and b/docs/assets/troubleshooting/difweightmodel.png differ diff --git a/docs/assets/troubleshooting/difweightmodel.svg b/docs/assets/troubleshooting/difweightmodel.svg new file mode 100644 index 0000000..02e60c6 --- /dev/null +++ b/docs/assets/troubleshooting/difweightmodel.svg @@ -0,0 +1,1291 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + a) + b) + + diff --git a/docs/examples/mtl_toy.ipynb b/docs/examples/mtl_toy.ipynb index b1d4a97..9594f87 100644 --- a/docs/examples/mtl_toy.ipynb +++ b/docs/examples/mtl_toy.ipynb @@ -9,7 +9,6 @@ "Here, we would like to show a classic and interesting toy example of multi-task learning (MTL). \n", "\n", "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/tum-pbs/ConFIG/blob/main/docs/examples/mtl_toy.ipynb)\n", - "[![Open Locally](../assets/download.svg)](https://github.com/tum-pbs/ConFIG/blob/main/docs/examples/mtl_toy.ipynb)\n", "\n", "In this example, there are two tasks represented by two loss functions, which are" ] @@ -446,7 +445,7 @@ ], "metadata": { "kernelspec": { - "display_name": "deeplearning", + "display_name": "config", "language": "python", "name": "python3" }, diff --git a/docs/examples/pinn_burgers.ipynb b/docs/examples/pinn_burgers.ipynb index 505e6af..064ddfe 100644 --- a/docs/examples/pinn_burgers.ipynb +++ b/docs/examples/pinn_burgers.ipynb @@ -10,7 +10,6 @@ "In this example, we would like to show you another example of how to use ConFIG method to train a physics informed neural network (PINN) for solving a PDE. \n", "\n", "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/tum-pbs/ConFIG/blob/main/docs/examples/pinn_burgers.ipynb)\n", - "[![Open Locally](../assets/download.svg)](https://github.com/tum-pbs/ConFIG/blob/main/docs/examples/pinn_burgers.ipynb)\n", "\n", "In this example, we will solve the 1D Burgers' equation:\n", "\n", diff --git a/docs/requirements.txt b/docs/requirements.txt index f4af116..02b2734 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -3,4 +3,5 @@ black mkdocs-material mkdocstrings mkdocstrings-python -mknotebooks +#mknotebooks +mkdocs-jupyter diff --git a/docs/start/troubleshooting.ipynb b/docs/start/troubleshooting.ipynb new file mode 100644 index 0000000..8fc9743 --- /dev/null +++ b/docs/start/troubleshooting.ipynb @@ -0,0 +1,179 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Troubleshooting\n", + "\n", + "Since we released the ConFIG method, we have received a lot of feedback from our users. Among many interesting discussions, we have found many useful tricks that may be helpful for the community. So, if you don't get a good result using ConFIG, please have a check on the following list:\n", + "\n", + "## Are you using different weight models?\n", + "\n", + "Introducing new direction weight models may raise some issues. For example, if you set your weights to $[1,2]$ for a two-loss scenario, the following two scenarios will both satisfy your weight condition:\n", + "\n", + "

\n", + "\n", + "

\n", + "\n", + "\n", + "Although in both situations the $\\mathbf{g}_c$ is a conflict-free direction, as $g_c$ has a positive dot product to both $\\mathbf{g}_1$ and $\\mathbf{g}_2$​. However, the situation in figure b) might not be the optimal direction. This situation will not occur when you are using the default equal weight models. Thus, we would recommend using the default weighting configuration as much as possible. \n", + "\n", + "## Are you using momentum-based optimizers?\n", + "\n", + "Momentum-based optimizers (here, we only refer to the optimizer that involves both the first and second momentum, e.g., Adam) might face some issues when you are using the default length model. In the default length model, the magnitude of the update gradient is calculated based on the sum of the projection length of each loss-specific direction, i.e.,\n", + "\n", + "$$\n", + "|\\mathbf{g}_{\\text{ConFIG}}|=\\sum_{i=1}^m \\mathbf{g}_i^\\top\\mathbf{g}_u=\\sum_{i=1}^m |\\mathbf{g}_i|\\mathcal{S}_c(\\mathbf{g}_i,\\mathbf{g}_u).\n", + "$$\n", + "\n", + "This means that the final magnitude of the update gradient relies on the \"angle\" between $\\mathbf{g}_i$s and the magnitude of each $\\mathbf{g_i}$. So, if one of your loss-specific gradients has a much larger magnitude than other gradients, then it will cover the magnitude distribution of other gradients.\n", + "\n", + "If you are using a momentum-based optimizer, the absolute value of $\\mathbf{g}_{\\text{ConFIG}}$ actually doesn't matter too much as momentum-based optimizers will adjust the learning rate (length of the update gradient) according to how the gradient changes. If the gradient changes rapidly, then the learning rate will be very small. Thus, if you have a very large loss-specific gradient, the momentum-based optimizers will just change the learning rate according to how the magnitude of this largest gradient changes and ignore the contribution from other gradients (the learning rate also depends on how the angle between loss-specific gradients, $\\mathcal{S}_c(\\mathbf{g}_i,\\mathbf{g}_u)$ changes, of course.).\n", + "\n", + "In our `conflictfree` package, we provide several following [length_model](../../api/length_model/) which can help you to decide which gradients' magnitude you want to track to adjust the learning rate in momentum-based optimizers. Here, we can use a simple example to illustrate the differences btween these length models:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from conflictfree.length_model import *\n", + "import matplotlib.pyplot as plt\n", + "\n", + "length_models=[\n", + " ProjectionLength(),\n", + " TrackMinimum(),\n", + " TrackMaximum(),\n", + " TrackArithmeticAverage(),\n", + " TrackGeometricAverage(),\n", + " TrackHarmonicAverage(),\n", + " TrackSpecific(0),\n", + " TrackSpecific(1),\n", + "]\n", + "\n", + "grad_1=torch.tensor([0,1.0])\n", + "grad_2=torch.tensor([0,1.0])\n", + "grad_1=grad_1/torch.norm(grad_1)\n", + "grad_2=grad_2/torch.norm(grad_2)\n", + "direction_final=grad_1+grad_2\n", + "grad_1=grad_1*10\n", + "gradients=torch.stack([grad_1,grad_2],dim=0)\n", + "\n", + "lengths=[grad_1.norm().item(),grad_2.norm().item()]\n", + "for model in length_models:\n", + " lengths.append(model.get_length(target_vector=direction_final,gradients=gradients).item())\n", + "labels=['$|g_1|$',\n", + " '$|g_2|$',\n", + " 'ProjectionLength (default)', \n", + " 'TrackMinimum', 'TrackMaximum', \n", + " 'TrackArithmeticAverage', \n", + " 'TrackGeometricAverage', \n", + " 'TrackHarmonicAverage', \n", + " 'TrackSpecific_0', \n", + " 'TrackSpecific_1']\n", + "\n", + "plt.bar(labels,lengths)\n", + "plt.xticks(rotation=90)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If your training result is not promising and you know that one of your loss-specific gradients has a much larger magnitude than other gradients, The `TrackMinimum` or `TrackHarmonicMean` might be a good choice worth trying.\n", + "\n", + "## Have you tried to warm up the learning rate?\n", + "\n", + "Usually, the direction of gradients at the start of the training may change rapidly due to the random initialization of the network. This may make it hard for the ConFIG method to find the optimal direction. Thus, we recommend you warm up the learning rate for a few epochs before applying the ConFIG method. This can be easily done by using the `torch.optim.lr_scheduler.LambdaLR` module. Here is an example of a cosine decay learning rate scheduler with warmup:" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import math\n", + "def get_cosine_lambda(initial_lr:float,\n", + " final_lr:float,\n", + " epochs:int,\n", + " warmup_epoch:int):\n", + " \"\"\"\n", + " Returns a lambda function that calculates the learning rate based on the cosine schedule.\n", + "\n", + " Args:\n", + " initial_lr (float): The initial learning rate.\n", + " final_lr (float): The final learning rate.\n", + " epochs (int): The total number of epochs.\n", + " warmup_epoch (int): The number of warm-up epochs.\n", + "\n", + " Returns:\n", + " function: The lambda function that calculates the learning rate.\n", + " \"\"\"\n", + " def cosine_lambda(idx_epoch):\n", + " if idx_epoch < warmup_epoch:\n", + " return idx_epoch / warmup_epoch\n", + " else:\n", + " return 1-(1-(math.cos((idx_epoch-warmup_epoch)/(epochs-warmup_epoch)*math.pi)+1)/2)*(1-final_lr/initial_lr)\n", + " return cosine_lambda\n", + "# from torch.optim.lr_scheduler import LambdaLR\n", + "# scheduler = LambdaLR(optimizer, lr_lambda=get_cosine_lambda(initial_lr=1e-3,final_lr=1e-4,epochs=100,warmup_epoch=10))\n", + "\n", + "cos_lambda=get_cosine_lambda(initial_lr=1e-3,final_lr=1e-4,epochs=100,warmup_epoch=10)\n", + "lrs=[cos_lambda(i) for i in range(100)]\n", + "plt.plot(lrs)\n", + "plt.grid()\n", + "plt.ylabel(\"Relative Learning Rate\")\n", + "plt.xlabel(\"Epochs\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "deeplearning", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/mkdocs.yml b/mkdocs.yml index e9213b7..75a99f4 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -18,6 +18,7 @@ theme: - navigation.top - navigation.footer - navigation.path + - announce.dismiss palette: - scheme: default primary: brown @@ -35,6 +36,7 @@ theme: repo: fontawesome/brands/github # GitHub logo in top right logo: assets/config_white.png favicon: assets/config_colorful.svg + custom_dir: overrides extra: social: @@ -60,14 +62,16 @@ markdown_extensions: - pymdownx.smartsymbols extra_javascript: - - javascripts/mathjax.js + - https://cdn.jsdelivr.net/npm/mathjax@2/MathJax.js?config=TeX-AMS_CHTML - https://polyfill.io/v3/polyfill.min.js?features=es6 - - https://unpkg.com/mathjax@3/es5/tex-mml-chtml.js plugins: - search # default search plugin; needs manually re-enabling when using any other plugins - autorefs # Cross-links to headings - - mknotebooks # Jupyter notebooks + #- mknotebooks # Jupyter notebooks + - mkdocs-jupyter: + include_requirejs: true + include_source: True - mkdocstrings: handlers: python: @@ -92,10 +96,11 @@ nav: - '2. Examples': - '2.1. Toy Example of Muti-task Learning': 'examples/mtl_toy.ipynb' - "2.2. Solve Burgers' Equation with PINN": 'examples/pinn_burgers.ipynb' - - '3. API Reference': - - "3.1. Gradient Operator": 'api/grad_operator.md' - - "3.2. Momentum Operator": 'api/momentum_operator.md' - - "3.3. Weight Model": 'api/weight_model.md' + - '3. Troubleshooting': 'start/troubleshooting.ipynb' + - '4. API Reference': + - "4.1. Gradient Operator": 'api/grad_operator.md' + - "4.2. Momentum Operator": 'api/momentum_operator.md' + - "4.3. Weight Model": 'api/weight_model.md' - "4.4. Length Model": 'api/length_model.md' - "4.5. Loss Recorder": 'api/loss_recorder.md' - "4.6. Utils": 'api/utils.md' diff --git a/overrides/main.html b/overrides/main.html new file mode 100644 index 0000000..abc47b7 --- /dev/null +++ b/overrides/main.html @@ -0,0 +1,14 @@ +{% extends "base.html" %} + +{% block content %} +{% if page.nb_url %} + + {% include ".icons/material/download.svg" %} + +{% endif %} +{{ super() }} +{% endblock content %} + +{% block announce %} +

💥 We have a new post on troubleshooting! Check it out here if you don't get good results using ConFIG. 💥

+ {% endblock %} \ No newline at end of file