Here we go.I have some problems.
First, I saw every time for model foward, we using same input "x".I can't understand, why not update copy-model by input x1, and update maml-model by input x2?Is the code same as paper?Maybe I am wrong.
Second, if we train image classification, we need to make data set.The data set consist of 50 picture, and every 10 picture from same class.So we have one task.However, I don't know how to define batch. Somebody tell me I can binding 4 task that means your train 4 task at the same time.I even don't know how to input my network, how it train.

Thanks for sharing your code.
I have a question, how to save the MAML weight? I tried save the MAML object using pickle but didn't work

Hi @mari-linhares , thanks for the repo!
We are building on your code to implement a bit more general version of MAML that includes a batch of tasks within the inner loop and several steps of gradient descent wrt the parameters of each task. However, we are stuck in how to add several steps of SGD within your code using tensorflow 2.0. Do you have any idea of how to do that?

The loss used for calculating the gradient to perform the meta update is only from one task. However, it should be the sum of all sampled tasks according to the original paper. Please look at step 8 in the code (below). The test_loss is inside the loop for i, t in enumerate(random.sample(dataset, len(dataset))), indicating the test_loss is only for one task.

# Step 2: instead of checking for convergence, we train for a number
# of epochs
for _ in range(epochs):
    total_loss = 0
    losses = []
    start = time.time()
    # Step 3 and 4
    for i, t in enumerate(random.sample(dataset, len(dataset))):
        **x, y = np_to_tensor(t.batch())**
        model.forward(x)  # run forward pass to initialize weights
        with tf.GradientTape() as test_tape:
            # test_tape.watch(model.trainable_variables)
            # Step 5
            with tf.GradientTape() as train_tape:
                train_loss, _ = compute_loss(model, x, y)
            # Step 6
            gradients = train_tape.gradient(train_loss, model.trainable_variables)
            k = 0
            model_copy = copy_model(model, x)
            for j in range(len(model_copy.layers)):
                model_copy.layers[j].kernel = tf.subtract(model.layers[j].kernel,
                            tf.multiply(lr_inner, gradients[k]))
                model_copy.layers[j].bias = tf.subtract(model.layers[j].bias,
                            tf.multiply(lr_inner, gradients[k+1]))
                k += 2
            # Step 8
            **test_loss**, logits = compute_loss(model_copy, **x, y**)
        # Step 8
        gradients = test_tape.gradient(**test_loss**, model.trainable_variables)
        optimizer.apply_gradients(zip(gradients, model.trainable_variables))

Hello thanx form the code it helped alot!

i have some questions for calculating test loss in MAML

when your code calculates test loss in train_maml() for specific sine function in inner loop

are you using same data to calculate both training and test loss?
shouldn't you sample new test data from same sine function to calculate test error like in the paper

thanx