# код рассчитан на python 3.7 и tensorflow 1.15.0
import datetime
from copy import deepcopy
import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
def _weight_variable(shape):
    # для весов полносвязного слоя инициализируем значения по Каймину Ге (Хе)
    stddev = 2. / np.sqrt(shape[0])
    initial = tf.random.truncated_normal(shape=shape, mean=0.0, stddev=stddev)
    return tf.Variable(initial, dtype=tf.float32)
def _bias_variable(shape):
    # смещения инициализируем нулями
    initial = tf.constant(0.0, shape=shape)
    return tf.Variable(initial, dtype=tf.float32)
class Model:
    def __init__(self, shape, session):
        """
        :param shape:   структура сети - список из чисел нейронов в каждом слое сети
                        от входа к выходу справа налево, например, [784, 100, 10]
        :param session: tensorflow-сессия для расчетов сети
        """
        self.session = session
        self._shape = shape
        depth = len(shape) - 1
        if depth < 1:
            raise ValueError("Недопустимая структура сети!")
        # заглушки для входных данных
        self.x = tf.placeholder(tf.float32, shape=[None, shape[0]])
        self.labels = tf.placeholder(tf.float32, shape=[None, shape[-1]])
        # все веса слоев сети будем хранить в списке
        self.var_list = []
        for ins, outs in zip(shape[:-1], shape[1:]):
            self.var_list.append(_weight_variable([ins, outs]))
            self.var_list.append(_bias_variable([outs]))
        # инициализируем веса сети
        for v in self.var_list:
            session.run(v.initializer)
        # список для хранения важностей весов сети
        self.wb_importance = [np.zeros(v.shape, dtype=np.float32) for v in self.var_list]
        # строим вычислительный граф
        x, y, z = self.x, None, None
        for i in range(depth):
            z = tf.matmul(x, self.var_list[i * 2]) + self.var_list[i * 2 + 1]
            y = tf.nn.softmax(z) if i == depth-1 else tf.nn.leaky_relu(z)
            x = y
        # функция стоимости
        self.loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=z, labels=self.labels))
        # точность (accuracy)
        self.correct_preds = tf.equal(tf.argmax(z, axis=1), tf.argmax(self.labels, axis=1))
        self.accuracy = tf.reduce_mean(tf.cast(self.correct_preds, tf.float32))
        # сэмплируем из выхода сети как из вероятностного распределения
        class_ind = tf.cast(tf.random.categorical(tf.math.log(y), 1)[0][0], tf.int32)
        # вычисляем градиенты вероятности
        self.prob_grads = tf.gradients(tf.math.log(y[0, class_ind]), self.var_list)
        self.train_step = None
    def open_lesson(self, learning_rate=1.0, lmbda=0.0):
        """
        Открытие урока обучения сети на отдельном датасете
        :param learning_rate: скорость обучения для SGD
        :param lmbda:         коэффициент влияния важностей - насколько сильно
                              важности тянут веса к эталонным значениям
        """
        loss = self.loss
        if hasattr(self, "star_vars") and lmbda != 0:
            # добавляем к функции стоимости слагаемые-регуляризаторы
            for v in range(len(self._shape)*2-2):
                loss += tf.reduce_sum(tf.multiply(
                    tf.constant(lmbda / 2. * self.wb_importance[v], tf.float32),
                    tf.square(self.var_list[v] - tf.constant(self.star_vars[v], tf.float32))
                ))
        # устанавливаем шаг оптимизатора
        self.train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)
    def close_lesson(self, closing_set=None):
        """
        Закрытие урока обучения сети на отдельном датасете. Расчет и накопление важностей весов.
        :param closing_set: датасет, на котором будут рассчитаны важности весов после обучения
        :return:
        """
        # рассчитываем важности весов на закрывающем датасете
        addendum = self._compute_fisher(closing_set)
        # добавляем рассчитанные важности к сохраненным
        for i, a in zip(self.wb_importance, addendum):
            i += a
        # запоминаем текущие эталонные веса сети после обучения
        self._store_weights_and_biases()
    def _store_weights_and_biases(self):
        self.star_vars = [v.eval() for v in self.var_list]
    def _compute_fisher(self, closing_set):
        # вычисление диагональных элементов информационной
        # матрицы Фишера для весов сети на заданном датасете
        num_samples = len(closing_set)
        # инициализируем значения нулями
        fisher = [np.zeros(self.var_list[v].shape, dtype=np.float32) for v in range(len(self.var_list))]
        for i in range(num_samples):
            # вычисляем первые производные логарифма вероятности
            feed_dict = {self.x: closing_set[i:i+1]}
            derivatives = self.session.run(self.prob_grads, feed_dict=feed_dict)
            # возводим их в квадрат т. к. это диагональные элементы
            for f, d in zip(fisher, derivatives):
                f += np.square(d)
        # усредняем по количеству примеров в датасете.
        # такой подход применим если мы хотим чтоб каждый урок оказывал одинаковый вклад в важности.
        # если же мы хотим чтоб каждый пример при закрытии урока оказывал одинаковое влияние, то
        # нужно делить на некую подобранную константу, а не на число примеров.
        for f in fisher:
            f /= num_samples
        return fisher
# функция случайным образом переставляет входы одинаково для всех примеров датасета
def permute_mnist(mnist):
    perm_inds = list(range(mnist.train.images.shape[1]))
    np.random.shuffle(perm_inds)
    mnist2 = deepcopy(mnist)
    sets = ["train", "validation", "test"]
    for set_name in sets:
        this_set = getattr(mnist2, set_name)
        this_set._images = np.transpose(np.array([this_set.images[:, c] for c in perm_inds]))
    return mnist2
def train_model(model, train_set, test_sets, batch_size=100, epochs=1):
    """
    Обучение модели
    :param model:       обучаемая модель
    :param train_set:   обучающий датасет
    :param test_sets:   список датасетов, на которых будет считаться средняя точность
    :param batch_size:  размер батча
    :param epochs:      количество эпох обучения
    :return:            средняя точность на тестовых датасетах после обучения
    """
    num_iters = int(np.ceil(len(train_set.train.labels) * epochs / batch_size))
    for idx in range(num_iters):
        train_batch = train_set.train.next_batch(batch_size)
        feed_dict = {model.x: train_batch[0], model.labels: train_batch[1]}
        model.train_step.run(feed_dict=feed_dict)
        print(f'\rTraining  {idx + 1}/{num_iters} done.', end='')
    print(f'\rTraining  {num_iters}/{num_iters} iterations done.')
    accuracy = 0.
    for t, test_set in enumerate(test_sets):
        feed_dict = {model.x: test_set.test.images, model.labels: test_set.test.labels}
        accuracy += model.accuracy.eval(feed_dict=feed_dict)
    accuracy /= len(test_sets)
    print(f'Evaluating on {len(test_sets)} test sets done. Accuracy {accuracy}')
    return accuracy
def continual_learning(net_struct, data_sets, session, lr, lmbda):
    """
    Последовательное обучение на нескольких обучающих наборах
    :param net_struct: структура сети
    :param data_sets:  список обучающих датасетов для последовательного обучения
    :param session:    tf-сессия
    :param lr:         скорость обучения
    :param lmbda:      степень влияния важностей на обучение
    :return:           список усредненных по выученным датасетам оценок
    """
    model = Model(net_struct, session)
    test_sets = []
    accuracies = []
    for data_set in data_sets:
        test_sets.append(data_set)
        model.open_lesson(lr, lmbda)
        accuracy = train_model(model, data_set, test_sets, 100, 4)
        accuracies.append(accuracy)
        model.close_lesson(data_set.validation.images)
    del model
    return accuracies
# считываем данные MNIST
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
# создаем tf-сессию
sess = tf.InteractiveSession()
# создаем 10 различных обучающих наборов для последовательного обучения
mnist0 = mnist
mnist1 = permute_mnist(mnist)
mnist2 = permute_mnist(mnist)
mnist3 = permute_mnist(mnist)
mnist4 = permute_mnist(mnist)
mnist5 = permute_mnist(mnist)
mnist6 = permute_mnist(mnist)
mnist7 = permute_mnist(mnist)
mnist8 = permute_mnist(mnist)
mnist9 = permute_mnist(mnist)
start_time = datetime.datetime.now()
# определим параметры обучения
data_sets = [mnist0, mnist1, mnist2, mnist3, mnist4, mnist5, mnist6, mnist7, mnist8, mnist9]
net_struct = [784, 300, 150, 10]
lmbda = 15.
learning_rate = 0.2
accuracies = continual_learning(net_struct, data_sets, sess, lr=learning_rate, lmbda=lmbda)
print ('Total time spent', datetime.datetime.now() - start_time)
dataset_num = range(1, len(accuracies) + 1)
# нарисуем график деградации средней точности на всех выученных датасетах
plt.figure(figsize=(7, 3.5))
plt.ylim(0.40, 1.)
plt.xlim(1, len(accuracies))
plt.ylabel('Total accuracy')
plt.xlabel('Number of tasks')
plt.plot(dataset_num, accuracies, marker=".")
#plt.legend()
plt.show()

# код рассчитан на python 3.7 и tensorflow 1.15.0
import datetime
from copy import deepcopy
import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
_epsilon = 0.1
def _weight_variable(shape):
    # для весов полносвязного слоя инициализируем значения по Каймину Ге (Хе)
    stddev = 2. / np.sqrt(shape[0])
    initial = tf.random.truncated_normal(shape=shape, mean=0.0, stddev=stddev)
    return tf.Variable(initial, dtype=tf.float32)
def _bias_variable(shape):
    # смещения инициализируем нулями
    initial = tf.constant(0.0, shape=shape)
    return tf.Variable(initial, dtype=tf.float32)
class Model:
    def __init__(self, shape, session):
        """
        :param shape:   структура сети - список из чисел нейронов в каждом слое сети
                        от входа к выходу справа налево, например, [784, 100, 10]
        :param session: tensorflow-сессия для расчетов сети
        """
        self.session = session
        self._shape = shape
        depth = len(shape) - 1
        if depth < 1:
            raise ValueError("Недопустимая структура сети!")
        # заглушки для входных данных
        self.x = tf.placeholder(tf.float32, shape=[None, shape[0]])
        self.labels = tf.placeholder(tf.float32, shape=[None, shape[-1]])
        # все веса слоев сети будем хранить в списке
        self.var_list = []
        for ins, outs in zip(shape[:-1], shape[1:]):
            self.var_list.append(_weight_variable([ins, outs]))
            self.var_list.append(_bias_variable([outs]))
        # инициализируем веса сети
        for v in self.var_list:
            session.run(v.initializer)
        # список для накопления важностей весов сети за текущий урок
        self._accums = [np.zeros(v.shape, dtype=np.float32) for v in self.var_list]
        # список для хранения важностей весов сети за все завершенные уроки
        self.wb_importance = [np.zeros(v.shape, dtype=np.float32) for v in self.var_list]
        # строим вычислительный граф
        x, y, z = self.x, None, None
        for i in range(depth):
            z = tf.matmul(x, self.var_list[i * 2]) + self.var_list[i * 2 + 1]
            y = tf.nn.softmax(z) if i == depth-1 else tf.nn.leaky_relu(z)
            x = y
        # функция стоимости
        self.loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=z, labels=self.labels))
        # точность (accuracy)
        self.correct_preds = tf.equal(tf.argmax(z, axis=1), tf.argmax(self.labels, axis=1))
        self.accuracy = tf.reduce_mean(tf.cast(self.correct_preds, tf.float32))
        self.grads = tf.gradients(self.loss, self.var_list)
        self._train_step = None
    def open_lesson(self, learning_rate=1.0, lmbda=0.0):
        """
        Открытие урока обучения сети на отдельном датасете
        :param learning_rate: скорость обучения для SGD
        :param lmbda:         коэффициент влияния важностей - насколько сильно
                              важности тянут веса к эталонным значениям
        """
        loss = self.loss
        if hasattr(self, "star_vars"):
            if lmbda != 0:
                # добавляем к функции стоимости слагаемые-регуляризаторы
                for v in range(len(self._shape)*2-2):
                    loss += tf.reduce_sum(tf.multiply(
                        tf.constant(lmbda / 2. * self.wb_importance[v], tf.float32),
                        tf.square(self.var_list[v] - tf.constant(self.star_vars[v], tf.float32))
                    ))
        else:
            # запоминаем текущие веса
            self.star_vars = [v.eval() for v in self.var_list]
        # устанавливаем шаг оптимизатора
        self._train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)
        #
        self.cur_vars = [v.eval() for v in self.var_list]
    def train_step_run(self, feed_dict):
        self._train_step.run(feed_dict=feed_dict)
        # считаем обновленные оптимизатором значения параметров сети
        new_vars = [v.eval() for v in self.var_list]
        # рассчитаем градиенты
        grads = self.session.run(self.grads, feed_dict=feed_dict)
        # аккумулируем изменение функции стоимости (производная
        # по параметру, умноженная на изменение параметра)
        for acc, grad, prev_var, new_var in zip(self._accums, grads, self.cur_vars, new_vars):
            acc -= grad * (new_var - prev_var)
        # мастера tensorflow вероятно смогут из train_step.run вытащить
        # уже подсчитанные градиенты по весам и сами изменения весов чтобы
        # не считать их еще раз и сэкономить вычислительные ресурсы
        # сохраним новые значения весов для следующей итерации
        self.cur_vars = new_vars
    def close_lesson(self):
        """
        Закрытие урока обучения сети. Накопление важностей весов.
        :return:
        """
        # рассчитаем квадраты смещений параметров
        deltas = [np.square(v.eval() - prev_v) + _epsilon
                  for v, prev_v in zip(self.var_list, self.star_vars)]
        # добавляем рассчитанные важности к сохраненным
        for i, a, d in zip(self.wb_importance, self._accums, deltas):
            i += a / d
        # запоминаем текущие эталонные веса сети после обучения
        self.star_vars = [v.eval() for v in self.var_list]
# функция случайным образом переставляет входы одинаково для всех примеров датасета
def permute_mnist(mnist):
    perm_inds = list(range(mnist.train.images.shape[1]))
    np.random.shuffle(perm_inds)
    mnist2 = deepcopy(mnist)
    sets = ["train", "validation", "test"]
    for set_name in sets:
        this_set = getattr(mnist2, set_name)
        this_set._images = np.transpose(np.array([this_set.images[:, c] for c in perm_inds]))
    return mnist2
def train_model(model, train_set, test_sets, batch_size=100, epochs=1):
    """
    Обучение модели
    :param model:       обучаемая модель
    :param train_set:   обучающий датасет
    :param test_sets:   список датасетов, на которых будет считаться средняя точность
    :param batch_size:  размер батча
    :param epochs:      количество эпох обучения
    :return:            средняя точность на тестовых датасетах после обучения
    """
    num_iters = int(np.ceil(len(train_set.train.labels) * epochs / batch_size))
    for idx in range(num_iters):
        train_batch = train_set.train.next_batch(batch_size)
        feed_dict = {model.x: train_batch[0], model.labels: train_batch[1]}
        model.train_step_run(feed_dict=feed_dict)
        print(f'\rTraining  {idx + 1}/{num_iters} done.', end='')
    print(f'\rTraining  {num_iters}/{num_iters} iterations done.')
    accuracy = 0.
    for t, test_set in enumerate(test_sets):
        feed_dict = {model.x: test_set.test.images, model.labels: test_set.test.labels}
        accuracy += model.accuracy.eval(feed_dict=feed_dict)
    accuracy /= len(test_sets)
    print(f'Evaluating on {len(test_sets)} test sets done. Accuracy {accuracy}')
    return accuracy
def continual_learning(net_struct, data_sets, session, lr, lmbda):
    """
    Последовательное обучение на нескольких обучающих наборах
    :param net_struct: структура сети
    :param data_sets:  список обучающих датасетов для последовательного обучения
    :param session:    tf-сессия
    :param lr:         скорость обучения
    :param lmbda:      степень влияния важностей на обучение
    :return:           список усредненных по выученным датасетам оценок
    """
    model = Model(net_struct, session)
    test_sets = []
    accuracies = []
    for data_set in data_sets:
        test_sets.append(data_set)
        model.open_lesson(lr, lmbda)
        accuracy = train_model(model, data_set, test_sets, 100, 4)
        accuracies.append(accuracy)
        model.close_lesson()
    del model
    return accuracies
# считываем данные MNIST
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
# создаем tf-сессию
sess = tf.InteractiveSession()
# создаем 10 различных обучающих наборов для последовательного обучения
mnist0 = mnist
mnist1 = permute_mnist(mnist)
mnist2 = permute_mnist(mnist)
mnist3 = permute_mnist(mnist)
mnist4 = permute_mnist(mnist)
mnist5 = permute_mnist(mnist)
mnist6 = permute_mnist(mnist)
mnist7 = permute_mnist(mnist)
mnist8 = permute_mnist(mnist)
mnist9 = permute_mnist(mnist)
start_time = datetime.datetime.now()
# определим параметры обучения
data_sets = [mnist0, mnist1, mnist2, mnist3, mnist4, mnist5, mnist6, mnist7, mnist8, mnist9]
net_struct = [784, 300, 150, 10]
lmbda = 0.1
learning_rate = 0.02
accuracies = continual_learning(net_struct, data_sets, sess, lr=learning_rate, lmbda=lmbda)
print ('Total time spent', datetime.datetime.now() - start_time)
dataset_num = range(1, len(accuracies) + 1)
# нарисуем график деградации средней точности на всех выученных датасетах
plt.figure(figsize=(7, 3.5))
plt.ylim(0.40, 1.)
plt.xlim(1, len(accuracies))
plt.ylabel('Total accuracy')
plt.xlabel('Number of tasks')
plt.plot(dataset_num, accuracies, marker=".")
#plt.legend()
plt.show()

# код рассчитан на python 3.7 и tensorflow 1.15.0
import datetime
from copy import deepcopy
import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
def _weight_variable(shape):
    # для весов полносвязного слоя инициализируем значения по Каймину Ге (Хе)
    stddev = 2. / np.sqrt(shape[0])
    initial = tf.random.truncated_normal(shape=shape, mean=0.0, stddev=stddev)
    return tf.Variable(initial, dtype=tf.float32)
def _bias_variable(shape):
    # смещения инициализируем нулями
    initial = tf.constant(0.0, shape=shape)
    return tf.Variable(initial, dtype=tf.float32)
class Model:
    def __init__(self, shape, session):
        """
        :param shape:   структура сети - список из чисел нейронов в каждом слое сети
                        от входа к выходу справа налево, например, [784, 100, 10]
        :param session: tensorflow-сессия для расчетов сети
        """
        self.session = session
        self._shape = shape
        depth = len(shape) - 1
        if depth < 1:
            raise ValueError("Недопустимая структура сети!")
        # заглушки для входных данных
        self.x = tf.placeholder(tf.float32, shape=[None, shape[0]])
        self.labels = tf.placeholder(tf.float32, shape=[None, shape[-1]])
        # все веса слоев сети будем хранить в списке
        self.var_list = []
        for ins, outs in zip(shape[:-1], shape[1:]):
            self.var_list.append(_weight_variable([ins, outs]))
            self.var_list.append(_bias_variable([outs]))
        # инициализируем веса сети
        for v in self.var_list:
            session.run(v.initializer)
        # список для хранения важностей весов сети
        self.wb_importance = [np.zeros(v.shape, dtype=np.float32) for v in self.var_list]
        # строим вычислительный граф
        x, y, z = self.x, None, None
        for i in range(depth):
            z = tf.matmul(x, self.var_list[i * 2]) + self.var_list[i * 2 + 1]
            y = tf.nn.softmax(z) if i == depth-1 else tf.nn.leaky_relu(z)
            x = y
        # функция стоимости
        self.loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=z, labels=self.labels))
        # точность (accuracy)
        self.correct_preds = tf.equal(tf.argmax(z, axis=1), tf.argmax(self.labels, axis=1))
        self.accuracy = tf.reduce_mean(tf.cast(self.correct_preds, tf.float32))
        # значения выходов сети
        F = tf.reduce_mean(tf.reduce_sum(tf.square(y), axis=1))
        # вычисляем градиенты значений по весам
        self.cur_importances = [tf.abs(grad) for grad in tf.gradients(F, self.var_list)]
        self.train_step = None
    def open_lesson(self, learning_rate=1.0, lmbda=0.0):
        """
        Открытие урока обучения сети на отдельном датасете
        :param learning_rate: скорость обучения для SGD
        :param lmbda:         коэффициент влияния важностей - насколько сильно
                              важности тянут веса к эталонным значениям
        """
        loss = self.loss
        if hasattr(self, "star_vars") and lmbda != 0:
            # добавляем к функции стоимости слагаемые-регуляризаторы
            for v in range(len(self._shape)*2-2):
                loss += tf.reduce_sum(tf.multiply(
                    tf.constant(lmbda / 2. * self.wb_importance[v], tf.float32),
                    tf.square(self.var_list[v] - tf.constant(self.star_vars[v], tf.float32))
                ))
        # устанавливаем шаг оптимизатора
        self.train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)
    def close_lesson(self, closing_set=None):
        """
        Закрытие урока обучения сети на отдельном датасете. Расчет и накопление важностей весов.
        :param closing_set: датасет, на котором будут рассчитаны важности весов после обучения
        :return:
        """
        # рассчитываем важности весов на закрывающем датасете
        addendum = self.session.run(self.cur_importances, feed_dict={self.x: closing_set})
        # добавляем рассчитанные важности к сохраненным
        for i, a in zip(self.wb_importance, addendum):
            i += a
        # запоминаем текущие эталонные веса сети после обучения
        self.star_vars = [v.eval() for v in self.var_list]
# функция случайным образом переставляет входы одинаково для всех примеров датасета
def permute_mnist(mnist):
    perm_inds = list(range(mnist.train.images.shape[1]))
    np.random.shuffle(perm_inds)
    mnist2 = deepcopy(mnist)
    sets = ["train", "validation", "test"]
    for set_name in sets:
        this_set = getattr(mnist2, set_name)
        this_set._images = np.transpose(np.array([this_set.images[:, c] for c in perm_inds]))
    return mnist2
def train_model(model, train_set, test_sets, batch_size=100, epochs=1):
    """
    Обучение модели
    :param model:       обучаемая модель
    :param train_set:   обучающий датасет
    :param test_sets:   список датасетов, на которых будет считаться средняя точность
    :param batch_size:  размер батча
    :param epochs:      количество эпох обучения
    :return:            средняя точность на тестовых датасетах после обучения
    """
    num_iters = int(np.ceil(len(train_set.train.labels) * epochs / batch_size))
    for idx in range(num_iters):
        train_batch = train_set.train.next_batch(batch_size)
        feed_dict = {model.x: train_batch[0], model.labels: train_batch[1]}
        model.train_step.run(feed_dict=feed_dict)
        print(f'\rTraining  {idx + 1}/{num_iters} done.', end='')
    print(f'\rTraining  {num_iters}/{num_iters} iterations done.')
    accuracy = 0.
    for t, test_set in enumerate(test_sets):
        feed_dict = {model.x: test_set.test.images, model.labels: test_set.test.labels}
        accuracy += model.accuracy.eval(feed_dict=feed_dict)
    accuracy /= len(test_sets)
    print(f'Evaluating on {len(test_sets)} test sets done. Accuracy {accuracy}')
    return accuracy
def continual_learning(net_struct, data_sets, session, lr, lmbda):
    """
    Последовательное обучение на нескольких обучающих наборах
    :param net_struct: структура сети
    :param data_sets:  список обучающих датасетов для последовательного обучения
    :param session:    tf-сессия
    :param lr:         скорость обучения
    :param lmbda:      степень влияния важностей на обучение
    :return:           список усредненных по выученным датасетам оценок
    """
    model = Model(net_struct, session)
    test_sets = []
    accuracies = []
    for data_set in data_sets:
        test_sets.append(data_set)
        model.open_lesson(lr, lmbda)
        accuracy = train_model(model, data_set, test_sets, 100, 4)
        accuracies.append(accuracy)
        model.close_lesson(data_set.validation.images)
    del model
    return accuracies
# считываем данные MNIST
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
# создаем tf-сессию
sess = tf.InteractiveSession()
# создаем 10 различных обучающих наборов для последовательного обучения
mnist0 = mnist
mnist1 = permute_mnist(mnist)
mnist2 = permute_mnist(mnist)
mnist3 = permute_mnist(mnist)
mnist4 = permute_mnist(mnist)
mnist5 = permute_mnist(mnist)
mnist6 = permute_mnist(mnist)
mnist7 = permute_mnist(mnist)
mnist8 = permute_mnist(mnist)
mnist9 = permute_mnist(mnist)
start_time = datetime.datetime.now()
# определим параметры обучения
data_sets = [mnist0, mnist1, mnist2, mnist3, mnist4, mnist5, mnist6, mnist7, mnist8, mnist9]
net_struct = [784, 300, 150, 10]
lmbda = 15.
learning_rate = 0.2
accuracies = continual_learning(net_struct, data_sets, sess, lr=learning_rate, lmbda=lmbda)
print ('Total time spent', datetime.datetime.now() - start_time)
dataset_num = range(1, len(accuracies) + 1)
# нарисуем график деградации средней точности на всех выученных датасетах
plt.figure(figsize=(7, 3.5))
plt.ylim(0.40, 1.)
plt.xlim(1, len(accuracies))
plt.ylabel('Total accuracy')
plt.xlabel('Number of tasks')
plt.plot(dataset_num, accuracies, marker=".")
#plt.legend()
plt.show()

# код рассчитан на python 3.7 и tensorflow 1.15.0
import datetime
from copy import deepcopy
import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
def _weight_variable(shape):
    # для весов полносвязного слоя инициализируем значения по Каймину Ге (Хе)
    stddev = 2. / np.sqrt(shape[0])
    initial = tf.random.truncated_normal(shape=shape, mean=0.0, stddev=stddev)
    return tf.Variable(initial, dtype=tf.float32)
def _bias_variable(shape):
    # смещения инициализируем нулями
    initial = tf.constant(0.0, shape=shape)
    return tf.Variable(initial, dtype=tf.float32)
class Model:
    def __init__(self, shape, session):
        """
        :param shape:   структура сети - список из чисел нейронов в каждом слое сети
                        от входа к выходу справа налево, например, [784, 100, 10]
        :param session: tensorflow-сессия для расчетов сети
        """
        self.session = session
        self._shape = shape
        depth = len(shape) - 1
        if depth < 1:
            raise ValueError("Недопустимая структура сети!")
        # заглушки для входных данных
        self.x = tf.placeholder(tf.float32, shape=[None, shape[0]])
        self.labels = tf.placeholder(tf.float32, shape=[None, shape[-1]])
        # все веса слоев сети будем хранить в списке
        self.var_list = []
        for ins, outs in zip(shape[:-1], shape[1:]):
            self.var_list.append(_weight_variable([ins, outs]))
            self.var_list.append(_bias_variable([outs]))
        # инициализируем веса сети
        for v in self.var_list:
            session.run(v.initializer)
        # список для хранения важностей весов сети
        self.wb_importance = [np.zeros(v.shape, dtype=np.float32) for v in self.var_list]
        # строим вычислительный граф
        outputs = []
        x, y, z = self.x, None, None
        for i in range(depth):
            z = tf.matmul(x, self.var_list[i * 2]) + self.var_list[i * 2 + 1]
            y = tf.nn.softmax(z) if i == depth-1 else tf.nn.leaky_relu(z)
            outputs.append(y)
            x = y
        # функция стоимости
        self.loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=z, labels=self.labels))
        # точность (accuracy)
        self.correct_preds = tf.equal(tf.argmax(z, axis=1), tf.argmax(self.labels, axis=1))
        self.accuracy = tf.reduce_mean(tf.cast(self.correct_preds, tf.float32))
        # вычисляем суммарный по модулю прошедший сигнал
        self.signals = []
        os = tf.reduce_mean(tf.abs(self.x), axis=0)
        for i in range(depth):
            ws = tf.transpose(tf.multiply(os, tf.transpose(tf.abs(self.var_list[i*2]))))
            self.signals.append(ws)
            os = tf.reduce_mean(tf.abs(outputs[i]), axis=0)
            self.signals.append(os)
        self.train_step = None
    def open_lesson(self, learning_rate=1.0, lmbda=0.0):
        """
        Открытие урока обучения сети на отдельном датасете
        :param learning_rate: скорость обучения для SGD
        :param lmbda:         коэффициент влияния важностей - насколько сильно
                              важности тянут веса к эталонным значениям
        """
        loss = self.loss
        if hasattr(self, "star_vars") and lmbda != 0:
            # добавляем к функции стоимости слагаемые-регуляризаторы
            for v in range(len(self._shape)*2-2):
                loss += tf.reduce_sum(tf.multiply(
                    tf.constant(lmbda / 2. * self.wb_importance[v], tf.float32),
                    tf.square(self.var_list[v] - tf.constant(self.star_vars[v], tf.float32))
                ))
        # устанавливаем шаг оптимизатора
        self.train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)
    def close_lesson(self, closing_set=None):
        """
        Закрытие урока обучения сети на отдельном датасете. Расчет и накопление важностей весов.
        :param closing_set: датасет, на котором будут рассчитаны важности весов после обучения
        :return:
        """
        # рассчитываем важности весов на закрывающем датасете
        addendum = self.session.run(self.signals, feed_dict={self.x: closing_set})
        # добавляем рассчитанные важности к сохраненным
        for i, a in zip(self.wb_importance, addendum):
            i += a
        # запоминаем текущие эталонные веса сети после обучения
        self.star_vars = [v.eval() for v in self.var_list]
# функция случайным образом переставляет входы одинаково для всех примеров датасета
def permute_mnist(mnist):
    perm_inds = list(range(mnist.train.images.shape[1]))
    np.random.shuffle(perm_inds)
    mnist2 = deepcopy(mnist)
    sets = ["train", "validation", "test"]
    for set_name in sets:
        this_set = getattr(mnist2, set_name)
        this_set._images = np.transpose(np.array([this_set.images[:, c] for c in perm_inds]))
    return mnist2
def train_model(model, train_set, test_sets, batch_size=100, epochs=1):
    """
    Обучение модели
    :param model:       обучаемая модель
    :param train_set:   обучающий датасет
    :param test_sets:   список датасетов, на которых будет считаться средняя точность
    :param batch_size:  размер батча
    :param epochs:      количество эпох обучения
    :return:            средняя точность на тестовых датасетах после обучения
    """
    num_iters = int(np.ceil(len(train_set.train.labels) * epochs / batch_size))
    for idx in range(num_iters):
        train_batch = train_set.train.next_batch(batch_size)
        feed_dict = {model.x: train_batch[0], model.labels: train_batch[1]}
        model.train_step.run(feed_dict=feed_dict)
        print(f'\rTraining  {idx + 1}/{num_iters} done.', end='')
    print(f'\rTraining  {num_iters}/{num_iters} iterations done.')
    accuracy = 0.
    for t, test_set in enumerate(test_sets):
        feed_dict = {model.x: test_set.test.images, model.labels: test_set.test.labels}
        accuracy += model.accuracy.eval(feed_dict=feed_dict)
    accuracy /= len(test_sets)
    print(f'Evaluating on {len(test_sets)} test sets done. Accuracy {accuracy}')
    return accuracy
def continual_learning(net_struct, data_sets, session, lr, lmbda):
    """
    Последовательное обучение на нескольких обучающих наборах
    :param net_struct: структура сети
    :param data_sets:  список обучающих датасетов для последовательного обучения
    :param session:    tf-сессия
    :param lr:         скорость обучения
    :param lmbda:      степень влияния важностей на обучение
    :return:           список усредненных по выученным датасетам оценок
    """
    model = Model(net_struct, session)
    test_sets = []
    accuracies = []
    for data_set in data_sets:
        test_sets.append(data_set)
        model.open_lesson(lr, lmbda)
        accuracy = train_model(model, data_set, test_sets, 100, 4)
        accuracies.append(accuracy)
        model.close_lesson(data_set.validation.images)
    del model
    return accuracies
# считываем данные MNIST
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
# создаем tf-сессию
sess = tf.InteractiveSession()
# создаем 10 различных обучающих наборов для последовательного обучения
mnist0 = mnist
mnist1 = permute_mnist(mnist)
mnist2 = permute_mnist(mnist)
mnist3 = permute_mnist(mnist)
mnist4 = permute_mnist(mnist)
mnist5 = permute_mnist(mnist)
mnist6 = permute_mnist(mnist)
mnist7 = permute_mnist(mnist)
mnist8 = permute_mnist(mnist)
mnist9 = permute_mnist(mnist)
start_time = datetime.datetime.now()
# определим параметры обучения
data_sets = [mnist0, mnist1, mnist2, mnist3, mnist4, mnist5, mnist6, mnist7, mnist8, mnist9]
net_struct = [784, 300, 150, 10]
lmbda = 1.
learning_rate = 0.2
accuracies = continual_learning(net_struct, data_sets, sess, lr=learning_rate, lmbda=lmbda)
print ('Total time spent', datetime.datetime.now() - start_time)
dataset_num = range(1, len(accuracies) + 1)
# нарисуем график деградации средней точности на всех выученных датасетах
plt.figure(figsize=(7, 3.5))
plt.ylim(0.40, 1.)
plt.xlim(1, len(accuracies))
plt.ylabel('Total accuracy')
plt.xlabel('Number of tasks')
plt.plot(dataset_num, accuracies, marker=".")
#plt.legend()
plt.show()

# код рассчитан на python 3.7 и tensorflow 1.15.0
import datetime
from copy import deepcopy
import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
from tensorflow.python.training.optimizer import Optimizer
def _weight_variable(shape):
    # для весов полносвязного слоя инициализируем значения по Каймину Ге (Хе)
    stddev = 2. / np.sqrt(shape[0])
    initial = tf.random.truncated_normal(shape=shape, mean=0.0, stddev=stddev)
    return tf.Variable(initial, dtype=tf.float32)
def _bias_variable(shape):
    # смещения инициализируем нулями
    initial = tf.constant(0.0, shape=shape)
    return tf.Variable(initial, dtype=tf.float32)
class _WVA_SGD(tf.train.GradientDescentOptimizer):
    def __init__(self, learning_rate, use_locking=False, name="GradientDescent"):
        super(_WVA_SGD, self).__init__(learning_rate, use_locking, name)
    def minimize(self, loss, global_step=None, var_list=None,
                 gate_gradients=Optimizer.GATE_OP, aggregation_method=None,
                 colocate_gradients_with_ops=False, name=None,
                 grad_loss=None, impacts=None):
        """ comments """
        grads_and_vars = self.compute_gradients(
            loss, var_list=var_list, gate_gradients=gate_gradients,
            aggregation_method=aggregation_method,
            colocate_gradients_with_ops=colocate_gradients_with_ops,
            grad_loss=grad_loss)
        vars_with_grad = [v for g, v in grads_and_vars if g is not None]
        if not vars_with_grad:
            raise ValueError(
                "No gradients provided for any variable, check your graph for ops"
                " that do not support gradients, between variables %s and loss %s." %
                ([str(v) for _, v in grads_and_vars], loss))
        if impacts is None:
            processed_grads_and_vars = grads_and_vars
        else:
            impact = iter(impacts)
            processed_grads_and_vars = []
            for g, v in grads_and_vars:
                if g is None:
                    processed_grads_and_vars.append((g, v))
                else:
                    processed_grads_and_vars.append((tf.multiply(g, next(impact)), v))
        return self.apply_gradients(processed_grads_and_vars,
                                    global_step=global_step,
                                    name=name)
class Model:
    def __init__(self, shape, session):
        """
        :param shape:   структура сети - список из чисел нейронов в каждом слое сети
                        от входа к выходу справа налево, например, [784, 100, 10]
        :param session: tensorflow-сессия для расчетов сети
        """
        self.session = session
        self._shape = shape
        depth = len(shape) - 1
        if depth < 1:
            raise ValueError("Недопустимая структура сети!")
        # заглушки для входных данных
        self.x = tf.placeholder(tf.float32, shape=[None, shape[0]])
        self.labels = tf.placeholder(tf.float32, shape=[None, shape[-1]])
        # все веса слоев сети будем хранить в списке
        self.var_list = []
        for ins, outs in zip(shape[:-1], shape[1:]):
            self.var_list.append(_weight_variable([ins, outs]))
            self.var_list.append(_bias_variable([outs]))
        # инициализируем веса сети
        for v in self.var_list:
            session.run(v.initializer)
        # список для хранения важностей весов сети
        self.wb_importance = [np.zeros(v.shape, dtype=np.float32) for v in self.var_list]
        # строим вычислительный граф
        outputs = []
        x, y, z = self.x, None, None
        for i in range(depth):
            z = tf.matmul(x, self.var_list[i * 2]) + self.var_list[i * 2 + 1]
            y = tf.nn.softmax(z) if i == depth-1 else tf.nn.leaky_relu(z)
            outputs.append(y)
            x = y
        # функция стоимости
        self.loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=z, labels=self.labels))
        # точность (accuracy)
        self.correct_preds = tf.equal(tf.argmax(z, axis=1), tf.argmax(self.labels, axis=1))
        self.accuracy = tf.reduce_mean(tf.cast(self.correct_preds, tf.float32))
        # вычисляем суммарный по модулю прошедший сигнал
        self.signals = []
        os = tf.reduce_mean(tf.abs(self.x), axis=0)
        for i in range(depth):
            ws = tf.transpose(tf.multiply(os, tf.transpose(tf.abs(self.var_list[i*2]))))
            self.signals.append(ws)
            os = tf.reduce_mean(tf.abs(outputs[i]), axis=0)
            self.signals.append(os)
        self.train_step = None
    def open_lesson(self, learning_rate=1.0, lmbda=0.0):
        """
        Открытие урока обучения сети на отдельном датасете
        :param learning_rate: скорость обучения для SGD
        :param lmbda:         коэффициент влияния важностей - насколько сильно
                              важности тянут веса к эталонным значениям
        """
        impacts = [tf.constant(1. / (1. + lmbda * v)) for v in self.wb_importance]
        # устанавливаем шаг оптимизатора
        self.train_step = _WVA_SGD(learning_rate).minimize(self.loss, impacts=impacts)
    def close_lesson(self, closing_set=None):
        """
        Закрытие урока обучения сети на отдельном датасете. Расчет и накопление важностей весов.
        :param closing_set: датасет, на котором будут рассчитаны важности весов после обучения
        :return:
        """
        # рассчитываем важности весов на закрывающем датасете
        addendum = self.session.run(self.signals, feed_dict={self.x: closing_set})
        # добавляем рассчитанные важности к сохраненным
        for i, a in zip(self.wb_importance, addendum):
            i += a
# функция случайным образом переставляет входы одинаково для всех примеров датасета
def permute_mnist(mnist):
    perm_inds = list(range(mnist.train.images.shape[1]))
    np.random.shuffle(perm_inds)
    mnist2 = deepcopy(mnist)
    sets = ["train", "validation", "test"]
    for set_name in sets:
        this_set = getattr(mnist2, set_name)
        this_set._images = np.transpose(np.array([this_set.images[:, c] for c in perm_inds]))
    return mnist2
def train_model(model, train_set, test_sets, batch_size=100, epochs=1):
    """
    Обучение модели
    :param model:       обучаемая модель
    :param train_set:   обучающий датасет
    :param test_sets:   список датасетов, на которых будет считаться средняя точность
    :param batch_size:  размер батча
    :param epochs:      количество эпох обучения
    :return:            средняя точность на тестовых датасетах после обучения
    """
    num_iters = int(np.ceil(len(train_set.train.labels) * epochs / batch_size))
    for idx in range(num_iters):
        train_batch = train_set.train.next_batch(batch_size)
        feed_dict = {model.x: train_batch[0], model.labels: train_batch[1]}
        model.train_step.run(feed_dict=feed_dict)
        print(f'\rTraining  {idx + 1}/{num_iters} done.', end='')
    print(f'\rTraining  {num_iters}/{num_iters} iterations done.')
    accuracy = 0.
    for t, test_set in enumerate(test_sets):
        feed_dict = {model.x: test_set.test.images, model.labels: test_set.test.labels}
        accuracy += model.accuracy.eval(feed_dict=feed_dict)
    accuracy /= len(test_sets)
    print(f'Evaluating on {len(test_sets)} test sets done. Accuracy {accuracy}')
    return accuracy
def continual_learning(net_struct, data_sets, session, lr, lmbda):
    """
    Последовательное обучение на нескольких обучающих наборах
    :param net_struct: структура сети
    :param data_sets:  список обучающих датасетов для последовательного обучения
    :param session:    tf-сессия
    :param lr:         скорость обучения
    :param lmbda:      степень влияния важностей на обучение
    :return:           список усредненных по выученным датасетам оценок
    """
    model = Model(net_struct, session)
    test_sets = []
    accuracies = []
    for data_set in data_sets:
        test_sets.append(data_set)
        model.open_lesson(lr, lmbda)
        accuracy = train_model(model, data_set, test_sets, 100, 4)
        accuracies.append(accuracy)
        model.close_lesson(data_set.validation.images)
    del model
    return accuracies
# считываем данные MNIST
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
# создаем tf-сессию
sess = tf.InteractiveSession()
# создаем 10 различных обучающих наборов для последовательного обучения
mnist0 = mnist
mnist1 = permute_mnist(mnist)
mnist2 = permute_mnist(mnist)
mnist3 = permute_mnist(mnist)
mnist4 = permute_mnist(mnist)
mnist5 = permute_mnist(mnist)
mnist6 = permute_mnist(mnist)
mnist7 = permute_mnist(mnist)
mnist8 = permute_mnist(mnist)
mnist9 = permute_mnist(mnist)
start_time = datetime.datetime.now()
# определим параметры обучения
data_sets = [mnist0, mnist1, mnist2, mnist3, mnist4, mnist5, mnist6, mnist7, mnist8, mnist9]
net_struct = [784, 300, 150, 10]
lmbda = 250.
learning_rate = 0.2
accuracies = continual_learning(net_struct, data_sets, sess, lr=learning_rate, lmbda=lmbda)
print ('Total time spent', datetime.datetime.now() - start_time)
dataset_num = range(1, len(accuracies) + 1)
# нарисуем график деградации средней точности на всех выученных датасетах
plt.figure(figsize=(7, 3.5))
plt.ylim(0.40, 1.)
plt.xlim(1, len(accuracies))
plt.ylabel('Total accuracy')
plt.xlabel('Number of tasks')
plt.plot(dataset_num, accuracies, marker=".")
#plt.legend()
plt.show()