" disuatu kondisi terdapat Singa. Singa itu awalnya berburu kerbau. kerbau dengan fisiknya yang besar, kuat dan bertanduk. pada awal-awal kemunculan singa, singa harus berburu kerbau, dan akhirnya Singa mempunyai pengetauan tentang bagaimana berburu Kerbau. 

setelah beberapa waktu Kerbau melakukan migrasi, pindah tempat ke tempat yang banyak rumput, sebagai sumber utama makanan dan akan kembali ke tempat semula di waktu rumput telah tumbuh lagi. 

Singa yang awalnya berburu Kerbau akhirnya harus berburu binatang yang lain. kebetulan waktu musim kemarau binatang yang menjadi buruan Singa adalah zebra. Singa harus belajar ulang bagaimana berburu Zebra, dan Singa tidak boleh kehilangan pengetahuan tentang berburu Kerbau. Jika nanti Kerbau kembali, maka pengetahuan itu harus tetap ada. "

Dari ilustrasi diatas, kita mendapat gambaran bahwa pengetahuan yang telah terkoleksi bagus tidak boleh hilang dikarenakan ada kondisi baru, karena pengetahuan yang lama masih tetap dibutuhkan untuk kondisi lama yang akan hadir lagi. kita bisa tidak bisa membayangkan jika kemampuan tersebut tidak ada pada Singa. 

kemudian apa hubunganya dengan Artificial Neural Network? conventional ANN tidak mempunyai kemampuan untuk beradaptasi terhadap kondisi baru, pilihanya adalah mentraining ulang jaringan jika ada kondisi baru, yang berarti menghilangkan nilai bobot dari data yang lama.  

penelitian tentang teknik ini ditulis dalam artikel dengan judul, "Overcoming catastrophics Forgeting in neural networks" yang ditulis oleh James Kirkparthick, dkk. Solusi yang ditawarkan pada artikel itu adalah dengan membuat elastik nilai bobot pada jaringan lama, ketika ada kondisi baru atau disebut dengan Elastic Weight Consolidation (EWC). bagaiamana kah konsep dari teknik ini? dan bagaiamna teknis implementasi dari teknik ini?

terdapat dua pendekatan (approach) output: shared output dan seperate output. 

misalkan terdapat task A dan task B. task disini dapat diartikan dataset.  Task A mempunyai dua kelas kerbau, dan gajah, sedangkan task B mempunyai class Zebra dan kijang. 

dengan pendekatan seperate output, maka langkah pertama adalah melatih jaringan dengan Task A dimana mempunyai 2 outputs. setelah satu jaringan terbentuk melalui pelatihan, maka jaringan tersebut digunakan lagi sebagai jaringan sebagai pelatihan Task B dengan output. maka dari itu ketika ada data testing dengan class zebra, maka mesin harus bisa membedakan Task A atau Task B yang digunakan, karena jika tidak dimasukkan ke satu jaringan yang tepat akan terjadi error yang besar. Zebra seharusnya terdapat pada Task B, jika salah masuk pada task A, maka mesin akan mengeluarkan output kerbau dan gajah, yang pasti sudah salah. 

pendekatan yang lain, shared output mempunyai cara kerja awal yang sama, tetapi ketika masuk ke Task B jaringan yang awalnya terdapat dua output akan menjadi empat output.  sehinga ketida ada test, dengan class apapun tidak harus berpindah jaringan. tetap pada satu jaringan yang sama dengan output yang bertambah. 

apa bedanya dengan transfer learning? transfer learning dalam pengertian umum, jaringanya akan dilatih dengan jaringan yang telah terlatih, tetapi dengan class yang sama, dan biasanya digunakan ketika terdapat dataset yang berbeda tetapi masih sama class. EWC dapat digunakan walaupun outputnya berbeda, tetapi dengan arsitektur jaringan yang sama, jadi ketika kita mempunyai data baru dengan penambahan class maka EWC akan menjadi rekomendasi yang digunakan, jika kita mengunakan cara lama, maka harus dilatih dari awal dengan dataset yang telah ditambahkan. 

secara teknis tentunya terdapat formula dan matrik yang digunakan, hal tersebut akan saya sampaikan lain waktu.. tetapi secara konsep hal ini seperti memberikan bobot seberapa penting pengetahuan lama. jika pengetahuan lama mempunyai nilai yang besar, maka jaringan akan bergerak secara lambat untuk belajar pengetahuan baru, diharapkan dengan teknik ini pengetahuan lama, tidak segera hilang atau masih ada foktor pemberat pengatahuan lama. 

Separate Output Approach

berikut ini adalah program untuk pendekatan separete output.. 

# Import necessary libraries

from sklearn.model_selection import train_test_split

import numpy as np

import tensorflow as tf

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense

from tensorflow.keras.utils import to_categorical

# Dummy data for tasks A and B (represents processed feature-label pairs)

# Task A: Classes 'dogs' and 'cats'

# Task B: Classes 'cats' and 'lions'

data_A = np.array([[1, 2], [2, 1], [3, 4], [4, 3], [5, 6]])  # Features for task A

labels_A = np.array(['dogs', 'cats', 'cats', 'dogs', 'dogs'])

data_B = np.array([[7, 8], [8, 7], [9, 10], [10, 9], [11, 12]])  # Features for task B

labels_B = np.array(['cats', 'lions', 'cats', 'lions', 'cats'])

# Convert labels to one-hot encoding using `to_categorical`

labels_A_one_hot = to_categorical([0 if label == 'dogs' else 1 for label in labels_A], num_classes=2)

labels_B_one_hot = to_categorical([0 if label == 'cats' else 1 for label in labels_B], num_classes=2)

# Split into training and testing sets for each task

X_train_A, X_test_A, y_train_A, y_test_A = train_test_split(data_A, labels_A_one_hot, test_size=0.2)

X_train_B, X_test_B, y_train_B, y_test_B = train_test_split(data_B, labels_B_one_hot, test_size=0.2)

# Define model for task A

model_A = Sequential([

    Dense(10, activation='relu', input_shape=(2,)),

    Dense(2, activation='softmax')  # 2 outputs for 'dogs' and 'cats'

])

model_A.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# Train model on task A

print("Training Model for Task A...")

model_A.fit(X_train_A, y_train_A, epochs=5, verbose=1)

# ==============================

# Compute Fisher Information after task A

# ==============================

def compute_fisher_information(model, X_data, y_data):

    fisher_info = {}

    with tf.GradientTape() as tape:

        predictions = model(X_data)

        loss = tf.keras.losses.categorical_crossentropy(y_data, predictions)

    gradients = tape.gradient(loss, model.trainable_variables)

    for i, grad in enumerate(gradients):

        fisher_info[model.trainable_variables[i].name] = tf.reduce_mean(grad ** 2).numpy()

    return fisher_info

fisher_info_A = compute_fisher_information(model_A, X_train_A, y_train_A)

# ==============================

# Define model for task B with EWC loss

# ==============================

lambda_ewc = 2.0  # Higher value to strongly preserve task A knowledge

class EWCModel(tf.keras.Model):

    def __init__(self, base_model, fisher_info, initial_weights, lambda_ewc):

        super(EWCModel, self).__init__()

        self.base_model = base_model

        self.fisher_info = fisher_info

        self.initial_weights = initial_weights

        self.lambda_ewc = lambda_ewc

    def call(self, inputs):

        return self.base_model(inputs)

    def ewc_loss(self, y_true, y_pred):

        # Standard categorical cross-entropy loss

        base_loss = tf.keras.losses.categorical_crossentropy(y_true, y_pred)

        # EWC penalty term

        ewc_penalty = 0

        for i, var in enumerate(self.base_model.trainable_variables):

            if var.name in self.fisher_info:

                ewc_penalty += self.fisher_info[var.name] * tf.reduce_sum((var - self.initial_weights[i]) ** 2)

        return base_loss + (self.lambda_ewc / 2) * ewc_penalty

# Save initial weights of task A

initial_weights_A = [tf.identity(w) for w in model_A.trainable_variables]

# Create a new model for task B

model_B = EWCModel(base_model=model_A, fisher_info=fisher_info_A, initial_weights=initial_weights_A, lambda_ewc=lambda_ewc)

model_B.compile(optimizer='adam', loss=model_B.ewc_loss, metrics=['accuracy'])

# Train model on task B

print("Training Model for Task B with EWC...")

model_B.fit(X_train_B, y_train_B, epochs=5, verbose=1)

# ==============================

# Evaluation

# ==============================

print("\nEvaluating Model on Task A:")

loss_A, acc_A = model_B.evaluate(X_test_A, y_test_A)

print(f"Task A Accuracy after learning Task B: {acc_A * 100:.2f}%")

print("\nEvaluating Model on Task B:")

loss_B, acc_B = model_B.evaluate(X_test_B, y_test_B)

print(f"Task B Accuracy: {acc_B * 100:.2f}%")

print("\nNote: This program implements Elastic Weight Consolidation (EWC) by computing Fisher information and adjusting the loss to preserve knowledge of Task A while learning Task B.")

hasil yang diperoleh dengan Task A mendapatkan hasil 100% akurasi dan Task B juga mendapatkan hasil 100%, yang berarti untuk satu model pembelajaran (Model.B) dapat menyelesaikan Task A dan Task B