Adam solvers are the hassle free standard for optimizers.

Empirically, Adam solvers converge faster and are more robust towards hyper-parameter settings than SGD. However, they generalize slightly worse. So, a good approach can be to start with Adam, and when you struggle to get good results, switch to the more costly SGD.

The intuition behind Adam solvers is similar to the one behind SGD. The main difference is though, that Adam solvers are adaptive notifiers. Adam also adjusts the learning rate based on the gradients' magnitude using Root Mean Square Propagation (RMSProp). This follows a similar logic as using momentum + dampening for SGD. This makes it robust for the non-convex optimization landscape of neural network.

import torch
\# N is batch size; D_in is input dimension;
\# H is hidden dimension; D_out is output dimension.
N, D_in, H, D_out = 64, 1000, 100, 10
\# Create random Tensors to hold inputs and outputs.
x = torch.randn(N, D_in)
y = torch.randn(N, D_out)
\# Use the nn package to define our model and loss function.
model = torch.nn.Sequential(
torch.nn.Linear(D_in, H),
torch.nn.ReLU(),
torch.nn.Linear(H, D_out),
)
loss_fn = torch.nn.MSELoss(reduction='sum')
\# Use the optim package to define an Optimizer that will update the weights of
\# the model for us. Here we will use Adam; the optim package contains many other
\# optimization algorithms. The first argument to the Adam constructor tells the
\# optimizer which Tensors it should update.
learning_rate = 1e-4
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
for t in range(500):
\# Forward pass: compute predicted y by passing x to the model.
y_pred = model(x)
\# Compute and print loss.
loss = loss_fn(y_pred, y)
print(t, loss.item())
\# Before the backward pass, use the optimizer object to zero all of the
\# gradients for the Tensors it will update (which are the learnable weights
\# of the model)
optimizer.zero_grad()
\# Backward pass: compute gradient of the loss with respect to model parameters
loss.backward()
\# Calling the step function on an Optimizer makes an update to its parameters
optimizer.step()

TensorFlow

\# importing the library
import tensorflow as tf
opt = tf.keras.optimizers.Adam(learning_rate=0.1)
var1 = tf.Variable(10.0)
loss = lambda: (var1 ** 2)/2.0 # d(loss)/d(var1) == var1
step_count = opt.minimize(loss, [var1]).numpy()
\# The first step is `-learning_rate*sign(grad)`
var1.numpy()