{"cells":[{"metadata":{"collapsed":true},"cell_type":"markdown","source":"# Active Learning Experiments\n\n### What is active learning\nActive learning is a machine learning setting where the learning algorithm decides what data to be labeled.\n### Why active learning\nThe key idea behind active learning is that a machine learning algorithm can\nachieve greater accuracy with fewer training labels if it is allowed to choose the\ndata from which it learns. An active learner may pose queries, usually in the form\nof unlabeled data instances to be labeled by an oracle (e.g., a human annotator).\nActive learning is well-motivated in many modern machine learning problems,\nwhere unlabeled data may be abundant or easily obtained, but labels are difficult,\ntime-consuming, or expensive to obtain."},{"metadata":{},"cell_type":"markdown","source":"### Let's get started"},{"metadata":{"_kg_hide-input":false,"trusted":true},"cell_type":"code","source":"# Some constants for dataset size and stroke paddings\nSTROKE_COUNT = 196\nTRAIN_SAMPLES = 50\nVALID_SAMPLES = 50\nTEST_SAMPLES = 50\nPOOL_SAMPLES = 250","execution_count":1,"outputs":[]},{"metadata":{"_kg_hide-input":false},"cell_type":"markdown","source":"### Load libraries and some utility plot functions"},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"%matplotlib inline\nimport os\nimport pickle\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport tensorflow as tf\nfrom keras.utils.np_utils import to_categorical\nfrom keras.preprocessing.sequence import pad_sequences\nfrom sklearn.preprocessing import LabelEncoder\nfrom sklearn.utils import shuffle\nimport pandas as pd\nfrom keras.metrics import top_k_categorical_accuracy\ndef top_3_accuracy(x,y): return top_k_categorical_accuracy(x,y, 3)\nfrom keras.callbacks import ModelCheckpoint, LearningRateScheduler, EarlyStopping, ReduceLROnPlateau\nfrom keras.models import Sequential\nfrom keras.layers import BatchNormalization, Conv1D, LSTM, Dense, Dropout\nfrom keras import backend as K\nfrom glob import glob\nimport gc\ngc.enable()\nfrom IPython.display import clear_output\n\ndef plot_history(history):\n    # Plot training & validation loss values\n    plt.plot(history['loss'])\n    plt.plot(history['val_loss'])\n    plt.title('Model loss')\n    plt.ylabel('Loss')\n    plt.xlabel('Epoch')\n    plt.legend(['Train', 'Test'], loc='upper left')\n    plt.show()\n\ndef plot_learn_process(process):\n    plt.plot(process[\"Percentage\"], process[\"Accuracy\"])\n    plt.title('Accuracy/Percentage')\n    plt.xlabel('percentage of data used')\n    plt.ylabel('accuracy on test data')\n    plt.show()\n    \ndef get_available_gpus():\n    from tensorflow.python.client import device_lib\n    local_device_protos = device_lib.list_local_devices()\n    return [x.name for x in local_device_protos if x.device_type == 'GPU']\nif len(get_available_gpus())>0:\n    from keras.layers import CuDNNLSTM as LSTM # this one is about 3x faster on GPU instances  \nbase_dir = os.path.join('..', 'input', 'quickdraw-doodle-recognition')\n# base_dir = os.path.join('..', 'input')\ntest_path = os.path.join(base_dir, 'test_simplified.csv')\ninline_process_template = \"../input/learning-process-inline/{}\"","execution_count":2,"outputs":[{"output_type":"stream","text":"Using TensorFlow backend.\n","name":"stderr"}]},{"metadata":{},"cell_type":"markdown","source":"### Load the dataset and preprocess the input"},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"from ast import literal_eval\nALL_TRAIN_PATHS = glob(os.path.join(base_dir, 'train_simplified', '*.csv'))\nCOL_NAMES = ['countrycode', 'drawing', 'key_id', 'recognized', 'timestamp', 'word']\n\ndef _stack_it(raw_strokes):\n    \"\"\"preprocess the string and make \n    a standard Nx3 stroke vector\"\"\"\n    stroke_vec = literal_eval(raw_strokes) # string->list\n    # unwrap the list\n    in_strokes = [(xi,yi,i)  \n     for i,(x,y) in enumerate(stroke_vec) \n     for xi,yi in zip(x,y)]\n    c_strokes = np.stack(in_strokes)\n    # replace stroke id with 1 for continue, 2 for new\n    c_strokes[:,2] = [1]+np.diff(c_strokes[:,2]).tolist()\n    c_strokes[:,2] += 1 # since 0 is no stroke\n    # pad the strokes with zeros\n    return pad_sequences(c_strokes.swapaxes(0, 1), \n                         maxlen=STROKE_COUNT, \n                         padding='post').swapaxes(0, 1)\ndef read_batch(samples=5, \n               start_row=0,\n               max_rows = 1000):\n    \"\"\"\n    load and process the csv files\n    this function is horribly inefficient but simple\n    \"\"\"\n    out_df_list = []\n    for c_path in ALL_TRAIN_PATHS:\n        c_df = pd.read_csv(c_path, nrows=max_rows, skiprows=start_row)\n        c_df.columns=COL_NAMES\n        out_df_list += [c_df.sample(samples)[['drawing', 'word']]]\n    full_df = pd.concat(out_df_list)\n    full_df['drawing'] = full_df['drawing'].\\\n        map(_stack_it)\n    \n    return full_df\n\ndef get_Xy(in_df):\n    X = np.stack(in_df['drawing'], 0)\n    y = to_categorical(word_encoder.transform(in_df['word'].values))\n    return X, y","execution_count":3,"outputs":[]},{"metadata":{"_kg_hide-input":false},"cell_type":"markdown","source":"### Here are class labels for the Quick Draw Game"},{"metadata":{"scrolled":false,"trusted":true,"_kg_hide-input":true},"cell_type":"code","source":"train_args = dict(samples=TRAIN_SAMPLES, \n                  start_row=0, \n                  max_rows=TRAIN_SAMPLES)\npool_args = dict(samples=POOL_SAMPLES, \n                 start_row=train_args['max_rows'], \n                 max_rows=POOL_SAMPLES)\nvalid_args = dict(samples=VALID_SAMPLES, \n                  start_row=train_args['max_rows']+pool_args['max_rows'], \n                  max_rows=VALID_SAMPLES)\ntest_args = dict(samples=TEST_SAMPLES, \n                 start_row=train_args['max_rows']+valid_args['max_rows']+pool_args['max_rows'], \n                 max_rows=TEST_SAMPLES)\n\ntrain_df = read_batch(**train_args)\nvalid_df = read_batch(**valid_args)\ntest_df = read_batch(**test_args)\npool_df = read_batch(**pool_args)\nword_encoder = LabelEncoder()\nword_encoder.fit(train_df['word'])\nprint('words', len(word_encoder.classes_), '=>', ', '.join([x for x in word_encoder.classes_]))","execution_count":4,"outputs":[{"output_type":"stream","text":"words 340 => The Eiffel Tower, The Great Wall of China, The Mona Lisa, airplane, alarm clock, ambulance, angel, animal migration, ant, anvil, apple, arm, asparagus, axe, backpack, banana, bandage, barn, baseball, baseball bat, basket, basketball, bat, bathtub, beach, bear, beard, bed, bee, belt, bench, bicycle, binoculars, bird, birthday cake, blackberry, blueberry, book, boomerang, bottlecap, bowtie, bracelet, brain, bread, bridge, broccoli, broom, bucket, bulldozer, bus, bush, butterfly, cactus, cake, calculator, calendar, camel, camera, camouflage, campfire, candle, cannon, canoe, car, carrot, castle, cat, ceiling fan, cell phone, cello, chair, chandelier, church, circle, clarinet, clock, cloud, coffee cup, compass, computer, cookie, cooler, couch, cow, crab, crayon, crocodile, crown, cruise ship, cup, diamond, dishwasher, diving board, dog, dolphin, donut, door, dragon, dresser, drill, drums, duck, dumbbell, ear, elbow, elephant, envelope, eraser, eye, eyeglasses, face, fan, feather, fence, finger, fire hydrant, fireplace, firetruck, fish, flamingo, flashlight, flip flops, floor lamp, flower, flying saucer, foot, fork, frog, frying pan, garden, garden hose, giraffe, goatee, golf club, grapes, grass, guitar, hamburger, hammer, hand, harp, hat, headphones, hedgehog, helicopter, helmet, hexagon, hockey puck, hockey stick, horse, hospital, hot air balloon, hot dog, hot tub, hourglass, house, house plant, hurricane, ice cream, jacket, jail, kangaroo, key, keyboard, knee, ladder, lantern, laptop, leaf, leg, light bulb, lighthouse, lightning, line, lion, lipstick, lobster, lollipop, mailbox, map, marker, matches, megaphone, mermaid, microphone, microwave, monkey, moon, mosquito, motorbike, mountain, mouse, moustache, mouth, mug, mushroom, nail, necklace, nose, ocean, octagon, octopus, onion, oven, owl, paint can, paintbrush, palm tree, panda, pants, paper clip, parachute, parrot, passport, peanut, pear, peas, pencil, penguin, piano, pickup truck, picture frame, pig, pillow, pineapple, pizza, pliers, police car, pond, pool, popsicle, postcard, potato, power outlet, purse, rabbit, raccoon, radio, rain, rainbow, rake, remote control, rhinoceros, river, roller coaster, rollerskates, sailboat, sandwich, saw, saxophone, school bus, scissors, scorpion, screwdriver, sea turtle, see saw, shark, sheep, shoe, shorts, shovel, sink, skateboard, skull, skyscraper, sleeping bag, smiley face, snail, snake, snorkel, snowflake, snowman, soccer ball, sock, speedboat, spider, spoon, spreadsheet, square, squiggle, squirrel, stairs, star, steak, stereo, stethoscope, stitches, stop sign, stove, strawberry, streetlight, string bean, submarine, suitcase, sun, swan, sweater, swing set, sword, t-shirt, table, teapot, teddy-bear, telephone, television, tennis racquet, tent, tiger, toaster, toe, toilet, tooth, toothbrush, toothpaste, tornado, tractor, traffic light, train, tree, triangle, trombone, truck, trumpet, umbrella, underwear, van, vase, violin, washing machine, watermelon, waterslide, whale, wheel, windmill, wine bottle, wine glass, wristwatch, yoga, zebra, zigzag\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_data = get_Xy(train_df)\npool_data = get_Xy(pool_df)\nval_data = get_Xy(valid_df)\ntest_data = get_Xy(test_df)","execution_count":5,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Set up the LSTM model\nThe quick draw recognizing sequence model is used to experiment with the active learning techniques.\n\n[Quick, Draw](https://quickdraw.withgoogle.com/) is a game made by Google AI to gather drawing dataset from the public for machine leaning research and the collected datasets are made public\n\nThe network structure used here is the same one used in tensorflow sequence [tutorial](https://www.tensorflow.org/tutorials/sequences/recurrent_quickdraw)\n\n![quick draw model image](https://www.tensorflow.org/images/quickdraw_model.png)"},{"metadata":{"trusted":true},"cell_type":"code","source":"stroke_read_model = Sequential()\nstroke_read_model.add(BatchNormalization(input_shape = (None, 3)))\n# filter count and length are taken from the script https://github.com/tensorflow/models/blob/master/tutorials/rnn/quickdraw/train_model.py\nstroke_read_model.add(Conv1D(48, (5,)))\nstroke_read_model.add(Dropout(0.3))\nstroke_read_model.add(Conv1D(64, (5,)))\nstroke_read_model.add(Dropout(0.3))\nstroke_read_model.add(Conv1D(96, (3,)))\nstroke_read_model.add(Dropout(0.3))\nstroke_read_model.add(LSTM(128, return_sequences = True))\nstroke_read_model.add(Dropout(0.3))\nstroke_read_model.add(LSTM(128, return_sequences = False))\nstroke_read_model.add(Dropout(0.3))\nstroke_read_model.add(Dense(512))\nstroke_read_model.add(Dropout(0.3))\nstroke_read_model.add(Dense(len(word_encoder.classes_), activation = 'softmax'))\nstroke_read_model.compile(optimizer = 'adam', \n                          loss = 'categorical_crossentropy', \n                          metrics = ['categorical_accuracy', top_3_accuracy])\nclear_output()","execution_count":6,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Class active_learner is the main object handling all the logic\nIt loads the pretrained weight and also controls things like how many rounds of selections we do for active learning, how many unlabeled data we select during each round, etc."},{"metadata":{"_kg_hide-input":false,"trusted":true},"cell_type":"code","source":"class active_learner:\n    def __init__(self, model, train, pool, val, test):\n        self.model = model\n        self.train = train\n        self.pool = pool\n        self.val = val\n        self.test = test\n        self.weight_path=\"../input/base-weight/{}_weights.best.hdf5\".format('stroke_lstm_model')\n#         self.weight_path=\"{}_weights.best.hdf5\".format('stroke_lstm_model')\n        checkpoint = ModelCheckpoint(self.weight_path, monitor='val_loss', verbose=1, \n                             save_best_only=True, mode='min', save_weights_only = True)\n        reduceLROnPlat = ReduceLROnPlateau(monitor='val_loss', factor=0.8, patience=10, \n                                           verbose=1, mode='auto', cooldown=5, min_lr=0.0001)\n        early = EarlyStopping(monitor=\"val_loss\", \n                              mode=\"min\", \n                              patience=3) # probably needs to be more patient, but kaggle time is limited\n        self.callbacks_list = [checkpoint, reduceLROnPlat, early]\n        self.__load_base()\n    \n    def __load_base(self, batch_size=4096):\n        model = self.model\n        weight_path = self.weight_path\n        callbacks_list = self.callbacks_list\n        train_x, train_y = self.train\n        val_x, val_y = self.val\n        \n        try:\n            model.load_weights(weight_path)\n        except:\n            history = model.fit(train_x, train_y,\n                                validation_data = (val_x, val_y), \n                                batch_size = batch_size,\n                                epochs = 500,\n                                verbose = 0,\n                                callbacks = callbacks_list[:-1])\n            clear_output()\n            plot_history(history.history)\n            \n    def learn(self, query_fn, prop=0.70, batch_size=4096, epoch_per_al_cycle=20, extra_label_per_epoch=200):\n        self.__load_base()\n        model = self.model\n        train_x, train_y = self.train\n        pool_x, pool_y = self.pool\n        val_x, val_y = self.val\n        test_x, test_y = self.test\n        \n        tot_size = len(train_x) + len(pool_x)\n        cur_size = len(train_x)\n        \n        lstm_results = model.evaluate(test_x, test_y, batch_size = batch_size)\n        print\n        learn_process = {\"Percentage\":[], \"Accuracy\":[]}\n        learn_process[\"Percentage\"].append(cur_size/tot_size)\n        learn_process[\"Accuracy\"].append(100*lstm_results[1])\n        \n        while cur_size/tot_size < prop:\n            rank = query_fn(model, pool_x)\n            selected_x, selected_y = pool_x[rank[:extra_label_per_epoch]], pool_y[rank[:extra_label_per_epoch]]\n            pool_x, pool_y = pool_x[rank[extra_label_per_epoch:]], pool_y[rank[extra_label_per_epoch:]]\n            train_x, train_y = np.vstack((train_x, selected_x)), np.vstack((train_y, selected_y))\n            \n            model.fit(train_x, train_y, \n                      validation_data = (val_x, val_y), \n                      batch_size = batch_size, \n                      epochs=epoch_per_al_cycle, \n                      callbacks = self.callbacks_list[1: ],\n                      verbose=0)\n            cur_size = len(train_x)\n#             print(cur_size/tot_size)\n            lstm_results = model.evaluate(test_x, test_y, batch_size = batch_size, verbose=0)\n            print(\"Test data accuracy is: \", 100*lstm_results[1])\n            learn_process[\"Percentage\"].append(cur_size/tot_size)\n            learn_process[\"Accuracy\"].append(100*lstm_results[1])\n        \n        return learn_process\n    \n    def evaluate(self):\n        model = self.model\n        test_x, test_y = self.test\n        lstm_results = stroke_read_model.evaluate(test_x, test_y, batch_size = 4096)\n        print('Accuracy: %2.1f%%, Top 3 Accuracy %2.1f%%' % (100*lstm_results[1], 100*lstm_results[2]))","execution_count":7,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"learner = active_learner(stroke_read_model, train_data, pool_data, val_data, test_data)","execution_count":8,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"We can evaluate our current model and see how well it does on the test dataset."},{"metadata":{"trusted":true},"cell_type":"code","source":"learner.evaluate()","execution_count":9,"outputs":[{"output_type":"stream","text":"17000/17000 [==============================] - 34s 2ms/step\nAccuracy: 0.5%, Top 3 Accuracy 1.3%\n","name":"stdout"}]},{"metadata":{},"cell_type":"markdown","source":"### There're different scenarios of active learning; We only experiment with pool-based here.\nGenerally, pool-based active learning algorithm follows this simple pattern:\n```\nGiven: Labeled set L, unlabeled pool U, query strategy Q, query batch size B\n\nrepeat\n    train the model on dataset L\n    for 1 to B\n        Pick the most informative label l according to strategy Q\n        add l to set L\n        remove l from U\nuntil some stopping criterion;\n```"},{"metadata":{},"cell_type":"markdown","source":"### Now it's obvious that the core part is the query strategy and the following strategies are introduced\n\n* uncertainty sampling\n    * least confidence\n    * margin\n    * entropy   \n* expected gradient length\n* submodular function optimization\n* submodularity and graph belief"},{"metadata":{},"cell_type":"markdown","source":"#### The learner object definied above provides a learn function that takes a query strategy as input and then do  the active learning cycle with the provided query strategy function\n\nLet's start with random selection as an example see how learner does the active learning.\nRandom selection just randomly select unlabeled data from the pool."},{"metadata":{"trusted":true},"cell_type":"code","source":"def random_selection(model, pool_x):\n    rank = shuffle(np.arange(pool_x.shape[0]))\n    return rank\n\ntry:\n    with open(inline_process_template.format(\"learn_process_random\"), 'rb') as f:\n        process = pickle.load(f)\nexcept:\n    # learn function returns accuracy with respect to the percentage of data labeled\n    process = learner.learn(random_selection)\n    \n# plot_learn_process will visualize the active learning process\nplot_learn_process(process)","execution_count":10,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"## 1. Uncertainty Sampling"},{"metadata":{},"cell_type":"markdown","source":"### Least Confidence\nSince the LSTM model gives probabilities of the unlabeled data belongs to each category. Least confidence selects labels that the current model has least greatest probility in determining how the unlabeled data to be categorized.\n$$\nx^*_{LC} = \\text{argmax}_x 1 − P_\\theta(y^*|x)\n$$\nwhere\n$$\ny* = \\text{argmax}_y P_\\theta(y|x)\n$$"},{"metadata":{"trusted":true},"cell_type":"code","source":"def confidence_selection(model, pool_x):\n    scores = model.predict(pool_x)\n    scores = np.max(scores, axis=1)\n    rank = np.argsort(scores)\n    return rank\n\ntry:\n    with open(inline_process_template.format(\"learn_process_confidence\"), 'rb') as f:\n        process = pickle.load(f)\nexcept:\n    # learn function returns accuracy with respect to the percentage of data labeled\n    process = learner.learn(confidence_selection)\n    \n# plot_learn_process will visualize the active learning process\nplot_learn_process(process)","execution_count":11,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"### Least Margin\nSimilar to the least confidence approach, we pick the unlabeled data that produces the least difference between the greatest and the second greatest probabilities.\n$$\nx^*_{LM} = \\text{argmin}_x P_\\theta(y_1|x) − P_\\theta(y_2|x)\n$$\nwhere $y_1$ and $y_2$ are the most and the second most likely label"},{"metadata":{"trusted":true},"cell_type":"code","source":"def margin_selection(model, pool_x):\n    scores = model.predict(pool_x)\n    scores_max = np.max(scores, axis=1)\n    max_idx = np.argmax(scores, axis=1)\n    scores[(np.arange(len(max_idx)), max_idx)] = 0\n    scores_secmax = np.max(scores, axis=1)\n    scores = scores_max-scores_secmax\n    rank = np.argsort(scores)\n    return rank\n\ntry:\n    with open(inline_process_template.format(\"learn_process_margin\"), 'rb') as f:\n        process = pickle.load(f)\nexcept:\n    # learn function returns accuracy with respect to the percentage of data labeled\n    process = learner.learn(margin_selection)\n    \n# plot_learn_process will visualize the active learning process\nplot_learn_process(process)","execution_count":12,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"### Greatest Entropy\nEntropy quantifies the uncertainty that the model holds on an unlabeled data. This approach simply selects the labels that our current model are most uncertain about."},{"metadata":{"trusted":true},"cell_type":"code","source":"def entropy_selection(model, pool_x):\n    scores = model.predict(pool_x)\n    log_scores = -scores*np.log2(scores)\n    scores = np.sum(scores, axis=1)\n    rank = np.argsort(-scores)\n    return rank\n\ntry:\n    with open(inline_process_template.format(\"learn_process_entropy\"), 'rb') as f:\n        process = pickle.load(f)\nexcept:\n    # learn function returns accuracy with respect to the percentage of data labeled\n    process = learner.learn(entropy_selection)\n    \n# plot_learn_process will visualize the active learning process\nplot_learn_process(process)","execution_count":13,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"## 2. Expected Gradient Length\nGradient quantifies how much we update the trainable weights in the model. This approach chooses the unlabeled data that will produce the greatest gradient when feed into the current model, so we choose the ones that impart the most to our model."},{"metadata":{},"cell_type":"markdown","source":"### Limitation\nDue to the limit in computation power and memory, we modified each round of active learning such that if x data need to be selected for this round, we select this x data from a randomly shuffled subpool with 5x data instead of the whole pool."},{"metadata":{"trusted":true},"cell_type":"code","source":"NUM_EGL_SELECTION = 100\ndef EGL_selection(model, pool_x, extra_label_per_epoch=NUM_EGL_SELECTION):\n    with tf.Session() as sess:\n#         print(\"before: \", pool_x.shape)\n        sess.run(tf.global_variables_initializer())\n        outputTensor = model.output\n        listOfVariableTensors = model.trainable_weights\n        gradients = K.gradients(outputTensor, listOfVariableTensors)\n        shuffled = shuffle(np.arange(len(pool_x)))\n        rnd_select = shuffled[:extra_label_per_epoch*5]\n        shuffled = shuffled[extra_label_per_epoch*5:]\n        scores = [-np.sum(list(map(\n                     lambda x: np.linalg.norm(x), \n                     sess.run(gradients, feed_dict={model.input:(input_data.reshape(1,-1,3))})\n                  ))) for input_data in list(pool_x[rnd_select])]\n        selected = rnd_select[np.argsort(scores)]\n        unselected = np.setdiff1d(rnd_select, selected)\n#         print(\"after: \", np.hstack((selected, unselected, shuffled)).shape)\n        return np.hstack((selected, unselected, shuffled))\n\ntry:\n    with open(inline_process_template.format(\"learn_process_egl\"), 'rb') as f:\n        process = pickle.load(f)\nexcept:\n    # learn function returns accuracy with respect to the percentage of data labeled\n    process = learner.learn(EGL_selection, extra_label_per_epoch=NUM_EGL_SELECTION)\n    \n# plot_learn_process will visualize the active learning process\nplot_learn_process(process)","execution_count":14,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"## 3. Submodular Function Optimization"},{"metadata":{"collapsed":true},"cell_type":"markdown","source":"A **submodular function** is a set function satisfying a natural diminishing returns property. We call a set\nfunction F defined over a ground set V submodular iff for all $A \\subseteq B \\subseteq V$ and $v \\in V \\backslash B$\n$$\nF(A + v) − F(A) \\ge F(B + v) − F(B)\n$$\nBasically the same thing as marginal returns in Economics.\n\nAnother simple property for the set function is that the function is monotone non-decreasing if for all $A \\subseteq B \\subseteq V$, $F(A) \\leq F(B)$.\n\n### Why do we need diminishing returns and monotone non-decreasing property?\nImagine you have 5 sensors and you want to properly place the sensors inside the office so that no matter which corner of the office could be on fire, on average the sensors should be able to detect the fire quickly. Another example is you have a social network relation graph of your customers, there's some costs with doing campaign for your products to one of the customers. But the characteristic of social network is that these customers may propagate information about your product to other people. The goal can be something like to using as few costs as possible while achieving campaign outcome of some measure $X$. \n\nThe first problem is known as submodular maximization problem and the second problem is called submodular set cover problem.\n\nIt turns out both problems are NP-Hard. However if the objective function (maximizing the fire sensoring and minimizing the campaign cost in the examples above) is submodular and monotone non-decreasing, a very simple greedy algorithm can be used to approximate the optimal value. The strtegy is just for current Set $S$ with objective value of $F(S)$, we pick the element $e$ that generates the largest benefit $F(S \\cup e) - F(S)$. The result get from the greedy strategy is no worse than $1-\\frac{1}{e}$ times the optimal value. (A theorem proved by Nemhauser et al '78)\n\n### Connection to active learning\nThe connection can be made with active learning because it is essentially a set cover problem where the goal is to minimize the labeled data put into the training data with the constraint of achieving some accuracy.\n\nThe only difference is that active learning is an adaptive version of submodular set cover problem in the sense that after one data is labeled, this newly labeled data should be included into the set when considering the data to be labeled next. \n\nDescibed in the paper:\n\nhttp://arxiv.org/pdf/1003.3967.pdf\n\nhttp://icml.cc/Conferences/2010/papers/436.pdf\n\nThe greedy algorithm is proved to have similar approximation as in the regular submodular set cover problem but with a lower bound(can perform worse when compared to optimal value).\n\nThe papers only give theoretical ideas of connecting submodular optimization with active learning but without hints to pick an proper objective submodular function. The tricky problem in this QuickDraw recognition setting, and probably in other deep neural network settings as well, is to find an objective function that measure the robustness and performance of the model with the diminishing return and monotone properties. Another thing to watch out is that when choosing unlabled data and evaluating the objective function, the actual labels of the data are unknown. \n\n### Some examples\nThere's a project: http://github.com/jmschrei/apricot that applies the submodularity on the data selection and very easy to use. The idea is to find the similarity between each pair of data and greedily select the data that are mostly different from others. Again the submodularity allows this approach to approximate relatively well while doing the job in polynomial time. However, the complexity finding the simiarity is quadratic to the size of unlabeled data. In the pool-based setting, the unlabeled pool is too big for this."},{"metadata":{},"cell_type":"markdown","source":"## 4. Submodularity and Graph Belief\nThe previous section talked about submodularity on a theoretical level and I find coming up with an objective function with the property of submodularity and monotonicity is quite hard.\n\nThis paper: http://openaccess.thecvf.com/content_cvpr_2017/papers/Paul_Non-Uniform_Subset_Selection_CVPR_2017_paper.pdf proposes an approach of constructing a graph with data as nodes to represent the relation between each pair of unlabeled data and then uses the node entropy and mutual information between each pair to construct the objective function. It is proved in the paper that the objective function is submodular and we can use submodular function minimization algorithm to efficiently solve the optimization problem.\n"},{"metadata":{},"cell_type":"markdown","source":"### Create a Loopy Belief Propagation Class\nThis class takes in a pool of data and connects each data to the 10 nearest other data points in Euclidean distance; then runs loopy belief propagation. Since we only have pairwise edge potential here, each factor in the factor graph is just a pair of adjacent nodes. For simplicty I also added factors with only 1 node for easier calculation."},{"metadata":{"trusted":true,"_kg_hide-input":true},"cell_type":"code","source":"# Pairwise Potential Loopy Belief Propagation\nclass LBP:\n    def __init__(self, model, data, num_classes=340, neighbour=10, iteration=2):\n        self.model = model\n        self.num_classes = num_classes\n        self.iteration = iteration\n        num_data = len(data)\n        factors = set(zip([-1]*num_data, range(num_data)))\n        for x in range(num_data):\n            lst = self.nearest_k_neighbours(data, x, neighbour)\n            for y in range(len(lst)):\n                factors.add((min(x, lst[y]), max(x, lst[y])))\n        factors = list(factors)\n        self.factors = factors\n        \n        node_to_factors = [[] for _ in range(num_data)]\n        order = []\n        for x in range(len(factors)):\n            if factors[x][0] != -1:\n                order = order + [(1, factors[x][0], x), (0, x, factors[x][0])]\n                node_to_factors[factors[x][0]].append(x)\n            order = order + [(1, factors[x][1], x), (0, x, factors[x][1])]\n            node_to_factors[factors[x][1]].append(x)\n        self.order = order\n        self.node_to_factors = node_to_factors\n        \n        self.node_po = list(model.predict(np.array(data)))\n        \n        num_factors = len(factors)\n        self.msg_node_factor = [[np.ones(num_classes) for j in range(len(node_to_factors[i]))] for i in range(num_data)]\n        self.msg_factor_node = [[np.ones(num_classes) for j in range(2)] for i in range(num_factors)]\n#         print(\"number of factors: \", num_factors)\n\n    def nearest_k_neighbours(self, data, x, k):\n        lst = []\n        for y in range(len(data)):\n            if x==y:\n                continue\n            d = np.linalg.norm(data[x]-data[y])\n            lst.append((d, y))\n            for i in range(len(lst)-1, 0, -1):\n                if lst[i][0] < lst[i-1][0]:\n                    lst[i-1], lst[i] = lst[i], lst[i-1]\n                else:\n                    break\n            if len(lst)>k:\n                lst.pop()\n        lst = [l[1] for l in lst]\n        return lst\n    \n    def pretty_print(self, e):\n        msg_node_factor = self.msg_node_factor\n        msg_factor_node = self.msg_factor_node\n        node_to_factors = self.node_to_factors\n        factors = self.factors\n        \n        if e[0]==0:\n            print(\"==========Factor to Node==========\")\n            print(\"From \", factors[e[1]], \" to \", e[2])\n            if(factors[e[1]][0]==e[2]):\n                print(msg_factor_node[e[1]][0][:10])\n                print(\"Sum is: \", np.sum(msg_factor_node[e[1]][0]))\n            else:\n                print(msg_factor_node[e[1]][1][:10])\n                print(\"Sum is: \", np.sum(msg_factor_node[e[1]][1]))\n            print(\"==================================\")\n        else:\n            print(\"==========Node to Factor==========\")\n            print(\"From \", e[1], \" to \", factors[e[2]])\n            print(msg_node_factor[e[1]][node_to_factors[e[1]].index(e[2])][:10])\n            print(\"Sum is: \", np.sum(msg_node_factor[e[1]][node_to_factors[e[1]].index(e[2])]))\n            print(\"==================================\")\n            \n    def converge(self):\n        order = self.order\n        factors = self.factors\n        node_po = self.node_po\n        node_to_factors = self.node_to_factors\n        msg_node_factor = self.msg_node_factor\n        msg_factor_node = self.msg_factor_node\n        num_classes = self.num_classes\n        \n        edge_po_matrix = 5*np.ones((num_classes, num_classes))\n        edge_po_matrix[range(num_classes), range(num_classes)] = 10\n        \n        for i in range(self.iteration):\n#             print(\"Iteration \", i, \":------------------------\")\n            order = shuffle(order)\n            for e in order:\n                # factor to node\n                if e[0] == 0:\n                    # for factor with id e[1], (a, b), if a is the target node\n                    if factors[e[1]][0] == e[2]:\n                        msg_factor_node[e[1]][0] = np.dot(edge_po_matrix, msg_node_factor[factors[e[1]][1]][node_to_factors[factors[e[1]][1]].index(e[1])])\n                    elif factors[e[1]][0]==-1:\n                        msg_factor_node[e[1]][1] = node_po[factors[e[1]][1]]\n                    # for factor with id e[1], (a, b), if b is the target node\n                    else:\n                        msg_factor_node[e[1]][1] = np.dot(edge_po_matrix, msg_node_factor[factors[e[1]][0]][node_to_factors[factors[e[1]][0]].index(e[1])])\n                    msg_factor_node[e[1]][1] = self.normalize_msg(msg_factor_node[e[1]][1])\n                    msg_factor_node[e[1]][0] = self.normalize_msg(msg_factor_node[e[1]][0])\n                # node to factor\n                else:\n                    new_msg = np.ones(num_classes)\n                    for j in node_to_factors[e[1]]:\n                        if j==e[2]:\n                            continue\n                        if e[1] == factors[j][0]:\n                            new_msg = new_msg * msg_factor_node[j][0]\n                        else:\n                            new_msg = new_msg * msg_factor_node[j][1]\n                        new_msg = self.normalize_msg(new_msg)\n                    msg_node_factor[e[1]][node_to_factors[e[1]].index(e[2])] = new_msg\n#                 self.pretty_print(e)\n    \n    def normalize_msg(self, msg):\n        s = np.sum(msg)\n        if s==0:\n            return msg\n        else:\n            return msg/s\n    \n    def get_belief(self):\n        factors = self.factors\n        msg_node_factor = self.msg_node_factor\n        msg_factor_node = self.msg_factor_node\n        node_to_factors = self.node_to_factors\n        node_po = self.node_po\n        belief = {}\n        for i in range(len(factors)):\n            fa = factors[i]\n            if fa[0]==-1:\n                belief[fa] = msg_node_factor[fa[1]][node_to_factors[fa[1]].index(i)]*node_po[fa[1]]\n            else:\n                belief[fa] = np.outer(msg_node_factor[fa[0]][node_to_factors[fa[0]].index(i)], msg_node_factor[fa[1]][node_to_factors[fa[1]].index(i)])\n                belief[fa] = self.normalize_msg(belief[fa])\n        return belief","execution_count":15,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Optimization\nIn the paper, it uses Fujishige-Wolfe Min Norm Point algorithm to solve the function minimization. Because the algorithm is complex and I did not find an existing implementation of this algorithm, so I turned to the lazy greedy algorithm from the previous section hoping for a good approximation."},{"metadata":{"trusted":true,"_kg_hide-input":true},"cell_type":"code","source":"import heapq\n\nclass submodular_opt:\n    def __init__(self, be, batch_pool_size):\n        M = np.zeros((batch_pool_size, batch_pool_size))\n        h = np.zeros(batch_pool_size)\n        for k, v in be.items():\n            if k[0]==-1:\n                v[v==0] = 0.01\n                h[k[1]] = np.sum(-v*np.log2(v))\n            else:\n                out = np.outer(be[(-1, k[0])], be[(-1, k[1])])\n                out[out==0] = 0.01\n                tmp_M = v*np.log2(v/out)\n                tmp_M[np.isnan(tmp_M)] = 0\n                tmp_M[tmp_M==-np.inf] = 0\n                tmp_M[tmp_M==np.inf] = 0\n                M[k[0], k[1]] = np.sum(tmp_M)\n                M[k[1], k[0]] = np.sum(tmp_M)\n        self.M = M\n        self.h = h\n        self.size = batch_pool_size\n        self.ones = np.ones(batch_pool_size)\n    \n    def obj_func(self, x):\n        M = self.M\n        h = self.h\n        ones = self.ones\n        return 0.5*x.dot(-M).dot(x) + x.dot(M.dot(ones)-h)\n    \n    def make_x(self, lst):\n        size = self.size\n        zeros = np.zeros(size)\n        zeros[lst] = 1\n        return zeros\n    \n    def lazy_greedy(self, k):\n        size = self.size\n        selections = []\n        pq = [[self.obj_func(self.make_x([i])), i, 0] for i in range(size)]\n        heapq.heapify(pq)\n        cur_obj = 0\n        for i in range(k):\n#             print(pq)\n            while True:\n                elem = heapq.heappop(pq)\n                if len(selections) == elem[2]:\n                    selections.append(elem[1])\n                    cur_obj = cur_obj + elem[0]\n                    break\n                else:\n                    elem[0] = self.obj_func(self.make_x(selections + [elem[1]])) - cur_obj\n                    elem[2] = len(selections)\n                    heapq.heappush(pq, elem)\n        return selections","execution_count":16,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Limitation\nSame as in the expected gradient length approach, we still struggle with the memory and computation, so we use the same strategy here. Notice that by doing this, our active learning setting is very similar to the stream-based scenario."},{"metadata":{"trusted":true},"cell_type":"code","source":"NUM_LOOPY_SFM_SELECTION = 100\ndef loopy_sfm_selection(model, pool_x, extra_label_per_epoch=NUM_LOOPY_SFM_SELECTION):\n#     print(pool_x.shape)\n    shuffled = shuffle(np.arange(len(pool_x)))\n    rnd_select = shuffled[:extra_label_per_epoch*5]\n    shuffled = shuffled[extra_label_per_epoch*5:]\n    pool_x = list(pool_x[rnd_select])\n    \n    lbp = LBP(model, pool_x, iteration=1)\n    lbp.converge()\n    be = lbp.get_belief()\n#     print([np.argmax(be[(-1, i)]) for i in range(extra_label_per_epoch)])\n    SFM = submodular_opt(be, extra_label_per_epoch*5)\n    selected = rnd_select[SFM.lazy_greedy(extra_label_per_epoch)]\n#     print(selected)\n    unselected = np.setdiff1d(rnd_select, selected)\n#     print(np.hstack((selected, unselected, shuffled)).shape)\n    return np.hstack((selected, unselected, shuffled))\n\ntry:\n    with open(inline_process_template.format(\"learn_process_submodule\"), 'rb') as f:\n        process = pickle.load(f)\nexcept:\n    # learn function returns accuracy with respect to the percentage of data labeled\n    process = learner.learn(EGL_selection, extra_label_per_epoch=NUM_LOOPY_SFM_SELECTION)\n    \n# plot_learn_process will visualize the active learning process\nplot_learn_process(process)","execution_count":17,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{}}]},{"metadata":{"_kg_hide-input":false},"cell_type":"markdown","source":"### Some Experiment results with larger pool example\n\nDue to applying the submodular optimization and expected gradient length approaches require long computation time. When the pool size gets larger, they become intractable and hence are not displayed on the plots below.\n\nThe following plots represent the learning processes of different active learning approaches mentioned above. The plot title shows how many training data, validation data, test data and pool data are used for each class label(there're 340 classes in total).\n\nIt seems that in the case of LSTM model for the Quick Draw game, only margin and confidence approaches are doing better most time; the other three sometimes perform worse than the random selection approach."},{"metadata":{"trusted":true,"_kg_hide-input":true},"cell_type":"code","source":"import re\ns = \"learn_process_(.+?)_\"\np = re.compile(s)\nprocess_template = \"../input/learning-process/{}\"\ncolors = ['green', 'blue', 'red', 'yellow', 'magenta', 'cyan']\n\ndef read_learning_process(filename):    \n    with open(process_template.format(filename), 'rb') as f:\n        content = pickle.load(f)\n    return content\n\ndef plot_all_learn_process(processes, title):\n    contents = [read_learning_process(process) for process in processes]\n    for i in range(len(contents)):\n        plt.plot(contents[i][\"Percentage\"], contents[i][\"Accuracy\"], colors[i])\n    plt.title('Accuracy/Percentage'+title)\n    plt.xlabel('percentage of data used')\n    plt.ylabel('accuracy on test data')\n    plt.legend([p.match(process).group(1) for process in processes], loc='upper left')\n    plt.show()\n\n# train, eval, test, pool\nprocess_50_100_100_200 = [\"learn_process_random_50_100_100_200\", \"learn_process_confidence_50_100_100_200\", \"learn_process_margin_50_100_100_200\", \"learn_process_entropy_50_100_100_200\", \"learn_process_egl_50_100_100_200\",\"learn_process_submodule_50_100_100_200\"]\nprocess_50_100_500_950 = [\"learn_process_random_50_100_500_950\", \"learn_process_confidence_50_100_500_950\", \"learn_process_margin_50_100_500_950\", \"learn_process_entropy_50_100_500_950\"]\nprocess_50_100_500_400 = [\"learn_process_random_50_100_500_400\", \"learn_process_confidence_50_100_500_400\", \"learn_process_margin_50_100_500_400\", \"learn_process_entropy_50_100_500_400\", \"learn_process_egl_50_100_500_400\"]\nprocess_100_100_100_400 = [\"learn_process_random_100_100_100_400\", \"learn_process_confidence_100_100_100_400\", \"learn_process_margin_100_100_100_400\", \"learn_process_entropy_100_100_100_400\", \"learn_process_egl_100_100_100_400\"]\nprocess_50_100_300_400 = [\"learn_process_random_50_100_300_400\", \"learn_process_confidence_50_100_300_400\", \"learn_process_margin_50_100_300_400\", \"learn_process_entropy_50_100_300_400\", \"learn_process_egl_50_100_300_400\"]\n\ntitle_str = \" - train: {}, validate: {}, test: {}, pool: {}\"\n\nplot_all_learn_process(process_50_100_100_200, title_str.format(50, 100, 100, 200))\nplot_all_learn_process(process_50_100_500_950, title_str.format(50, 100, 500, 950))\nplot_all_learn_process(process_50_100_500_400, title_str.format(50, 100, 500, 400))\nplot_all_learn_process(process_100_100_100_400, title_str.format(100, 100, 100, 400))\nplot_all_learn_process(process_50_100_300_400, title_str.format(50, 100, 300, 400))","execution_count":18,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{}}]}],"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.6.3"}},"nbformat":4,"nbformat_minor":1}