{"id":20807446,"url":"https://github.com/tikquuss/lwd","last_synced_at":"2026-04-29T12:37:12.854Z","repository":{"id":53259079,"uuid":"294684390","full_name":"Tikquuss/lwd","owner":"Tikquuss","description":"Learning with derivative","archived":false,"fork":false,"pushed_at":"2021-02-21T19:25:59.000Z","size":23694,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"master","last_synced_at":"2025-03-12T03:45:01.998Z","etag":null,"topics":["autograd","financial-functions","mlp","pytorch","siren","sobolev","sobolev-training","tensorflow"],"latest_commit_sha":null,"homepage":"","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/Tikquuss.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null}},"created_at":"2020-09-11T12:04:33.000Z","updated_at":"2022-08-04T16:38:50.000Z","dependencies_parsed_at":"2022-08-27T07:10:59.081Z","dependency_job_id":null,"html_url":"https://github.com/Tikquuss/lwd","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/Tikquuss/lwd","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Tikquuss%2Flwd","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Tikquuss%2Flwd/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Tikquuss%2Flwd/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Tikquuss%2Flwd/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/Tikquuss","download_url":"https://codeload.github.com/Tikquuss/lwd/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Tikquuss%2Flwd/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":28002267,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","status":"online","status_checked_at":"2025-12-24T02:00:07.193Z","response_time":83,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["autograd","financial-functions","mlp","pytorch","siren","sobolev","sobolev-training","tensorflow"],"created_at":"2024-11-17T19:37:46.858Z","updated_at":"2025-12-24T12:16:50.143Z","avatar_url":"https://github.com/Tikquuss.png","language":"Python","funding_links":[],"categories":[],"sub_categories":[],"readme":"This repository contains the code for :\n* [Sobolev Training for Neural Networks](https://arxiv.org/abs/1706.04859)\n* [Differential Machine Learning](https://arxiv.org/abs/2005.02347) \n* [Implicit Neural Representations with Periodic Activation Functions](https://arxiv.org/abs/2006.09661)\n\nTest on different functions :\n* Those used in Sobolev Training paper (see this [notebook](notebooks/optimization_functions.ipynb)) :\n    * [Styblinski-Tang](https://www.sfu.ca/~ssurjano/stybtang.html)\n    * [Ackley](http://www.sfu.ca/~ssurjano/ackley.html)\n    * [Beale](https://www.sfu.ca/~ssurjano/beale.html)\n    * [Booth](https://www.sfu.ca/~ssurjano/booth.html)\n    * [Bukin](https://www.sfu.ca/~ssurjano/bukin6.html)\n    * [McCormick](https://www.sfu.ca/~ssurjano/mccorm.html)\n    * [Rosenbrock](https://www.sfu.ca/~ssurjano/rosen.html)\n\n* Those used in Differential Machine Learning paper (see this [notebook](notebooks/financial_functions.ipynb)) :\n    * Pricing and Risk Functions : Black \u0026 Scholes ([wikipedia](https://en.wikipedia.org/wiki/Black%E2%80%93Scholes_model))\n    * Gaussian Basket options : Bachelier dimension 1, 7, 20...([mathworks](https://www.mathworks.com/help/finance/pricing-american-basket-options-by-monte-carlo-simulation.html))\n\nTo summarize, you have the possibility to form a network following one of these processes :\n* Normal Training (x, y) : with MLP (multi-layer perceptron) and Siren\n* Sobolev Training (x, y, dy/dx) : with MLP and Siren\n* Twin_net tensorflow (x, y, dy/dx) : with MLP and Siren\n* Twin_net pytorch (x, y, dy/dx) : with MLP and Siren\n\n# **How to train your one model?**\n```bash\ngit clone https://github.com/Tikquuss/lwd\ncd lwd/scripts\n```\n## **(i) For achitecture made with pytorch (Normal Training, Sobolev Training and Twin_net pytorch): [utils.py](scripts/utils.py) and [functions.py](scripts\\functions.py)**\n\n### **Data**  \n\nThe genData function takes a :\n* function : f(x : array), return y \n* its derivative: f'(i: int), takes i as parameter and returns another function that takes x and returns df(x)/dx[i]=dy/dx[i].\n* dim_x : dimension of x\n* the boundaries of the domain in which the points will be generated unify the points\n* the number of examples (n) to be generated\n* and the random seed for reproducibility\n\nand returns (xi, yi, [dydx[j], j=1...dim_x]), i = 1….n\n\n**Example with the Styblinski-Tang function**\n````python\nfrom utils import genData, get_data_loader\nfrom functions import STFunction, STDeriv\n\nmin_x, max_x = -5, 5\nbatch_size = 32\nnormalize = False # whether you want to normalize the data or not.\nnTrain = 10000 # number of examples to be generated for training\nnTest = 10000 # number of examples to be generated for the test\nINPUT_DIM = 2\n\ntrain_seed, test_seed = 0, 1 # for reproducibility\n\nbatch_samples = genData(function = STFunction, deriv_function = STDeriv, dim_x = INPUT_DIM, min_x = min_x, max_x = max_x, num_samples = nTrain, random_seed = train_seed)\nx, y, dydx = zip(*batch_samples)\ntrain_dataloader, config = get_data_loader(x = x, y = y, dydx = dydx, batch_size = batch_size, normalize = normalize)\n\nbatch_samples = genData(function = STFunction, deriv_function = STDeriv, dim_x = INPUT_DIM, min_x = min_x, max_x = max_x, num_samples = nTest, random_seed = test_seed)\nx, y, dydx = zip(*batch_samples)\ntest_dataloader, _ = get_data_loader(x = x, y = y, dydx = dydx, batch_size = batch_size, normalize = False)\n````\n\n* **Note: case of financial functions (Black \u0026 Scholes, Bachelier)**\n````python\ntry:\n    %tensorflow_version 1.x\n    %matplotlib inline\nexcept Exception:\n    pass\n\nfrom twin_net_tf import get_diffML_data_loader, BlackScholes, Bachelier\n\ngenerator = BlackScholes() # or Bachelier(n = INPUT_DIM) for Bachelier dimension INPUT_DIM\nwith_derivative = True # with dydx or not\n\ntrain_dataloader, test_dataloader, xAxis, vegas, config = get_diffML_data_loader(\n        generator = generator, \n        nTrain = nTrain, nTest = nTest, \n        train_seed = train_seed, test_seed = test_seed, \n        batch_size = batch_size, with_derivative = with_derivative,\n        normalize = normalize\n    )\n````\n\nIf `normalize = True`, config will be a dictionary containing the following key-value pairs:\n- \"x_mean\": mean of x\n- \"x_std\" : variance of x\n- \"y_mean\": mean of y\n- \"y_std\" : variance of y\n- \"lambda_j\", \"get_alpha_beta\" and \"n\" : see the section \"**How it works?**\" below.\n\nIf you are in dimension 2, you can visualize the curve of your function and its deviation as follows:\n````python\nfrom utils import plotFunction, plotGrad\n\nmin_y, max_y =  -5, 5 \nstep_x, step_y = 0.25, 0.25\n\nplotFunction(name = \"Styblinski-Tang Function\", \n             function = STFunction, \n             min_x = min_x, max_x = max_x, step_x = step_x, \n             min_y = min_y, max_y = max_y, step_y = step_y)\n\nplotGrad(name = \"Gradient Field of Styblinski-Tang Function\", \n         deriv_function = STDeriv, \n         min_x = min_x, max_x = max_x, step_x = step_x, \n         min_y = min_y, max_y = max_y, step_y = step_y)\n````\n\n* **hyperparameters in the different loss functions to express a tradeoff between y loss and dydx loss**\n````python \n# Leave None and None instead of 1 and 1\nloss_config = {'alpha': None, \"beta\" : None} # loss = alpha * loss_y + beta * loss_dydx\nconfig.update({key : value for key, value in loss_config.items() if value})\n````\n\nSavine et al. applied the recent [one-cycle learning rate schedule](https://arxiv.org/abs/1803.09820) of Leslie Smith and found that it considerably accelerates and stabilizes the training of neural networks.\nThis parameter was introduced for this purpose, and remains optional (so you can override these two lines of code, and the learning rate will be used as described below).\n```python\nlearning_rate_schedule = [(0.0, 1.0e-8), (0.2, 0.1), (0.6, 0.01), (0.9, 1.0e-6), (1.0, 1.0e-8)]\nif not learning_rate_schedule is None :\n    config[\"learning_rate_schedule\"] = learning_rate_schedule\n```  \n\n### **Model**\n\n* *Parameters of the model*\n\n```python\nHIDDEN_DIM = 20\nN_HIDDEN = 2 # number of hidden layers\nOUTPUT_DIM = 1\n```\n\n* *case of multi-layer perceptron*\n\n```python\nimport torch\nimport torch.nn.functional as F\nfrom utils import MLP\n\nactivation_function = F.softplus\nderiv_activation_function = torch.sigmoid # for twin_net (backprop)\nmlp_model_kwargs = {\"in_features\" : INPUT_DIM, # depends on the function\n                    \"hidden_features\" : HIDDEN_DIM, \n                    \"hidden_layers\" : N_HIDDEN, \n                    \"out_features\": OUTPUT_DIM, \n                    \"activation_function\" : activation_function, \n                    \"deriv_activation_function\" : deriv_activation_function,\n                   }\nmodel = MLP(**mlp_model_kwargs)\n```\n* *case of Siren*\n```python\nfrom utils import Siren\nfirst_omega_0 = 30.\nhidden_omega_0 = 30.\noutermost_linear = True\n\nsiren_model_kwargs = {\"in_features\" : INPUT_DIM, \n                      \"hidden_features\" : HIDDEN_DIM, \n                      \"hidden_layers\" : N_HIDDEN, \n                      \"out_features\": OUTPUT_DIM, \n                      \"outermost_linear\" : outermost_linear, \n                      \"first_omega_0\" : first_omega_0, \n                      \"hidden_omega_0\" : hidden_omega_0}\n\nmodel = Siren(**siren_model_kwargs)\n```\n\n### **Optimizer and loss function**\n```python\nlearning_rate = 3e-5\noptimizer = torch.optim.Adam(model.parameters(), lr = learning_rate)\ncriterion = torch.nn.MSELoss()\n```\n### **Training, visualization of training statistics and testing**\nIf you want to save the best model obtained during training.\n```python\nname = \"net\" # for normal and sobolev training, \"twin_net\" for twin_net (do not specify any other value than the last two)\n#name = \"twin_net\" # for twin_net (do not specify any other value than the last two)\n\nconfig[\"dump_path\"] = \"/content\" # folder in which the models will be stored (left to None/False/0/\"\" if we don't want to save the models)\nconfig[\"function_name\"] = \"\"\nmodel_name = name # 'net', 'twin_net'\nif name == \"net\" :\n    model_name = \"normal\" if not with_derivative else \"sobolev\"\nmodel_name += \"-norm\" if normalize else \"\"\nmodel_name += \"-lrs\" if learning_rate_schedule else \"\"\nconfig[\"model_name\"] = model_name\nconfig[\"nTrain\"] = nTrain\nconfig[\"batch_size\"] = batch_size\n```\n\n```python\nfrom utils import train, plot_stat, test\n\n# with_derivative = False # for normal training\nwith_derivative = True # for sobolev training and twin_net \n\nmax_epoch = 1000 # maximun number of epoch\nimproving_limit = float(\"inf\") # Stop training if the training loss does not decrease n times (no limit here)\n\nmodel, stats, best_loss = train(\n    name, model, train_dataloader, \n    optimizer, criterion, config, \n    with_derivative, max_epoch = max_epoch, \n    improving_limit = improving_limit\n)\n\n\nplot_stat(stats, with_derivative = with_derivative)\n\n(test_loss, r_y, r_dydx), (x_list, y_list, dydx_list, y_pred_list, dydx_pred_list) = test(\n        name, model, test_dataloader, criterion, config, with_derivative\n    )\n```\nIf you are in dimension 2 and want to visualize the curves produced by your models :\n\n```python\nfrom utils import forward, backprop, gradient\n\nx_mean, x_std = config.get(\"x_mean\", 0.), config.get(\"x_std\", 1.)\ny_mean, y_std = config.get(\"y_mean\", 0.), config.get(\"y_std\", 1.)\n\ndef function(x):\n    x = torch.tensor(x)\n    x_scaled = (x-x_mean) / x_std\n    y_pred_scaled = model(x = x_scaled.float())\n    y_pred = y_mean + y_std * y_pred_scaled\n    y_pred = y_pred.detach().squeeze().numpy()\n    return y_pred\n\ndef deriv_function(index):\n    def f(x) :\n        x = torch.tensor(x, requires_grad = True)\n        x_scaled = (x-x_mean) / x_std\n        if name == \"net\" :\n            y_pred_scaled = model(x = x_scaled.float()) \n            dydx_pred_scaled = gradient(y_pred_scaled, x_scaled)\n        elif name == \"twin_net\" :\n            y_pred_scaled, zs = forward(net = model.net, x = x_scaled.float(), return_layers = True)\n            dydx_pred_scaled = backprop(net = model.net, y = y_pred_scaled, zs = zs)\n        dydx_pred = y_std / x_std * dydx_pred_scaled\n        dydx_pred = dydx_pred.detach().squeeze().numpy()\n        return dydx_pred[index]\n    return f\n\nplotFunction(name = \"Styblinski-Tang Function foo foo\", \n             function = function, \n             min_x = min_x, max_x = max_x, step_x = step_x, \n             min_y = min_y, max_y = max_y, step_y = step_y)\n\nplotGrad(name = \"Gradient Field of Styblinski-Tang Function foo foo\", \n         deriv_function = deriv_function, \n         min_x = min_x, max_x = max_x, step_x = step_x, \n         min_y = min_y, max_y = max_y, step_y = step_y)\n```\n* **Note: case of financial functions**\n```python\nimport matplotlib.pyplot as plt\n\nxy = [(x[0], y[0]) for x, y in zip(x_list, y_list)]\nxy_pred = [(x[0], y[0]) for x, y in zip(x_list, y_pred_list)]\n  \nif with_derivative :\n    xdydx = [(x[0], y[0]) for x, y in zip(x_list, dydx_list)]\n    xdydx_pred = [(x[0], y) for x, y in zip(x_list, dydx_pred_list)]\n\n    fig, (ax1, ax2) = plt.subplots(1, 2, sharex=True, figsize = (15,3))\nelse :\n    fig, ax1 = plt.subplots(1, 1, sharex=True, figsize = (15,3))\n\nfig.suptitle('foo')\n    \nax1.scatter(*zip(*xy), label = \"y\")\nax1.scatter(*zip(*xy_pred), label = \"ypred\")\nax1.set(xlabel='x', ylabel='y, y_pred')\nax1.legend()\nif with_derivative :\n    ax2.scatter(*zip(*xdydx), label = \"dy\")\n    ax2.scatter(*zip(*xdydx_pred), label = \"dy pred\")\n    ax2.set(xlabel='x', ylabel='dy, dy_pred')\n    ax2.legend()\n```\n\n## **(ii) For achitecture made with tensorflow (Twin_net tensorflow) : [utils.py](scripts/utils.py), [twin_net_tf.py](scripts/twin_net_tf.py), [twin_net_tf_siren.py](scripts/twin_net_tf_siren.py) and [functions.py](scripts\\functions.py)**\n\n```python\ntry:\n    %tensorflow_version 1.x\n    %matplotlib inline\nexcept Exception:\n    pass\n```\n\n### **Generator to be used to produce training and test data.**\n\n```python\nfrom twin_net_tf import Generator\nfrom functions import STFunction, STDeriv\n\nmin_x, max_x = -5, 5\nINPUT_DIM = 2\ngenerator = Generator(callable_function = STFunction, \n                      callable_function_deriv = STDeriv, \n                      dim_x = INPUT_DIM,\n                      min_x = min_x, max_x = max_x)\n```\n### **Training, testing and visualization of training statistics**\n```python\nimport tensorflow.keras as K\ntf_config = {\"init_weights\" : init_weights, \"input_dim\" : OUTPUT_DIM}\ntf_config.update({\"activation_function\" : K.activations.softplus, \"deriv_activation_function\" : K.activations.sigmoid})\n\nconfig = {}\nconfig[\"learning_rate_schedule\"] = learning_rate_schedule\nconfig[\"learning_rate\"] = learning_rate\nconfig.update({key : value for key, value in loss_config.items() if value})\nconfig.update(tf_config)\nconfig[\"dump_path\"] = \"\"\nconfig[\"function_name\"] = \"\" \nmodel_name = \"\"\nmodel_name += \"-norm\" if normalize else \"\"\nmodel_name += \"-lrs\" if learning_rate_schedule else \"\"\nconfig[\"model_name\"] = \"\"\nconfig[\"nTrain\"] = nTrain\nconfig[\"batch_size\"] = batch_size\n\n```\n```python\nfrom twin_net_tf import test as twin_net_tf_test \nfrom utils import plot_stat\n\nsiren = True # set to True if you want to use siren as backbone\nnTrain = 3 # number of examples to be generated for training\nnTest = 3 # number of examples to be generated for the test\ntrain_seed, test_seed = 0, 1\nbatch_size = 20\nwith_derivative = True\n\nHIDDEN_DIM = 20\nN_HIDDEN = 2\ngenerator_kwargs = {\"hidden_units\" : HIDDEN_DIM, \n                    \"hidden_layers\" : N_HIDDEN}\n\nmax_epoch = 2 # maximun number of epoch\nimproving_limit = float(\"inf\") # Stop training if the training loss does not decrease n times (no limit here)\n\nif siren :\n    \n    first_omega_0 = 30.\n    hidden_omega_0 = 30.\n    outermost_linear = True\n    config.update({\"first_omega_0\" : first_omega_0, \n               \"hidden_omega_0\": hidden_omega_0, \n                \"outermost_linear\" : outermost_linear})\n            \n    config[\"activation_function\"] = tf.math.sin\n    config[\"deriv_activation_function\"] = tf.math.cos\n\n    \nloss, regressor, dtrain, dtest, dydxTest, values, deltas = twin_net_tf_test(\n    generator, [nTrain], \n    nTrain, nTest, \n    trainSeed = train_seed, testSeed = test_seed, weightSeed = 0, \n    deltidx = 0,\n    generator_kwargs = generator_kwargs,\n    epochs = max_epoch,\n    improving_limit = improving_limit,\n    min_batch_size = batch_size,\n    config = config\n)\n\nplot_stat(regressor.stats[\"normal\"], with_derivative = True)\nplot_stat(regressor.stats[\"differential\"], with_derivative = True)\n```\nIf you are in dimension 2 and want to visualize the curves produced by your models :\n```python\nimport numpy as np\nfrom utils import plotFunction, plotGrad\nfrom twin_net_tf import graph\n\ngraph_name = \"Styblinski-Tang\"\nmin_y, max_y =  -5, 5 \nstep_x, step_y = 0.25, 0.25\n\nplotFunction(name = \"Styblinski-Tang Function foo foo\", function =  lambda x : regressor.predict_values([x])[0][0], \n             min_x = min_x, max_x = max_x, step_x = step_x, \n             min_y = min_y, max_y = max_y, step_y = step_y)\n\nplotGrad(name = \"Gradient Field of Styblinski-Tang Function foo foo\", \n         deriv_function = lambda index : lambda x : regressor.predict_values_and_derivs([x])[1][0][index], \n         min_x = min_x, max_x = max_x, step_x = step_x, \n         min_y = min_y, max_y = max_y, step_y = step_y)\n\n\n# show_graph_per_axis\nyTest = dtest[1]\nfor i in range(INPUT_DIM) :\n    xAxis  = np.array([[x[i]] for x in dtest[0]])\n    # show predicitions\n    graph(\"%s x%d vs y\" % (graph_name, (i+1)), values, xAxis, \"\", \"values\", yTest, [nTrain], True)\n    # show deltas\n    graph(\"%s x%d vs dxdy\" % (graph_name, (i+1)), deltas, xAxis, \"\", \"deltas\", dydxTest, [nTrain], True) \n```\n**For financial functions**\n```python\nfrom twin_net_tf import BlackScholes, Bachelier\nINPUT_DIM = 1\ngenerator = BlackScholes() # or Bachelier(n = INPUT_DIM) for Bachelier dimension INPUT_DIM\n```\n```python\nfrom twin_net_tf import test as twin_net_tf_test \nfrom utils import plot_stat\n\nsiren = True # set to True if you want to use siren as backbone\nnTrain = 3 # number of examples to be generated for training\nnTest = 3 # number of examples to be generated for the test\ntrain_seed, test_seed = 0, 1\nbatch_size = 20\nwith_derivative = True\n\nHIDDEN_DIM = 20\nN_HIDDEN = 2\ngenerator_kwargs = {\"hidden_units\" : HIDDEN_DIM, \n                    \"hidden_layers\" : N_HIDDEN}\n\nmax_epoch = 2 # maximun number of epoch\nimproving_limit = float(\"inf\") # Stop training if the training loss does not decrease n times (no limit here)\n\nif siren :\n    first_omega_0 = 30.\n    hidden_omega_0 = 30.\n    outermost_linear = True\n    config.update({\"first_omega_0\" : first_omega_0, \n               \"hidden_omega_0\": hidden_omega_0, \n                \"outermost_linear\" : outermost_linear})\n            \n    config[\"activation_function\"] = tf.math.sin\n    config[\"deriv_activation_function\"] = tf.math.cos\n\ndic_loss, regressor, dtrain, dtest, dydxTest, values, deltas, xAxis, vegas = twin_net_tf_test(\n    generator, [nTrain], \n    nTrain, nTest, \n    trainSeed = train_seed, testSeed = test_seed, weightSeed = 0, \n    deltidx = 0,\n    generator_kwargs = generator_kwargs,\n    epochs = max_epoch,\n    improving_limit = improving_limit,\n    min_batch_size = batch_size\n)\n\nplot_stat(regressor.stats[\"normal\"], with_derivative = with_derivative)\nplot_stat(regressor.stats[\"differential\"], with_derivative = with_derivative)\n```\n```python\nfrom twin_net_tf import graph\nimport numpy as np\n\ngraph_name = \"Black \u0026 Scholes\"\nyTest = dtest[1]\n# show predicitions\ngraph(graph_name, values, xAxis, \"\", \"values\", yTest, [nTrain], True)\n# show deltas\ngraph(graph_name, deltas, xAxis, \"\", \"deltas\", dydxTest, [nTrain], True)\n\n# show_graph_per_axis \nfor i in range(INPUT_DIM) :\n    xAxis = np.array([[x[i]] for x in dtest[0]])\n    # show predicitions\n    graph(\"%s x%d vs y\" % (graph_name, (i+1)), values, xAxis, \"\", \"values\", yTest, [nTrain], True)\n    # show deltas\n    graph(\"%s x%d vs dxdy\" % (graph_name, (i+1)), deltas, xAxis, \"\", \"deltas\", dydxTest, [nTrain], True)\n```\n\n# **How it works?**\n## Forward \n*TODO*\n## Backprop vs. Gradient\n*TODO*\n## Siren\n*TODO*\n## Data normalization\n*TODO*\n## Loss\n*TODO*\n\n# References\n\n* https://github.com/mcneela/Sobolev\n* https://github.com/differential-machine-learning/notebooks\n* https://github.com/vsitzmann/siren","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Ftikquuss%2Flwd","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Ftikquuss%2Flwd","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Ftikquuss%2Flwd/lists"}