TinghuiWang / pyActLearn

                return

            injector = BatchInjector(data_x=train_x, data_y=train_y, batch_size=batch_size)

            i = 0

            while _pretrain_criterion.continue_learning():

                batch_x, batch_y = injector.next_batch()

                if summaries_dir is not None and (i % summary_interval == 0):

                    summary, loss = session.run(

                        [current_layer.merged, current_layer.encode_loss],

                        feed_dict={self.x: x, self.y_: y}

                    )

                    train_writer.add_summary(summary, i)

                    logger.info('Pre-training Layer %d, Step %d, training loss %g' % (j, i, loss))

                    if test_x is not None and test_y is not None:

                        summary, loss = session.run(

                            [current_layer.merged, current_layer.encode_loss],

                            feed_dict={self.x: test_x, self.y_: test_y}

                        )

                        test_writer.add_summary(summary, i)

                        logger.info('Pre-training Layer %d, Step %d, test loss %g' % (j, i, loss))

                    if pretrain_criterion == 'monitor_based':

                        summary, loss = session.run(

                            [current_layer.merged, current_layer.encode_loss],

                            feed_dict={self.x: valid_x, self.y_: valid_y}

                        )

                        valid_writer.add_summary(summary, i)

                        logger.info('Pre-training Layer %d, Step %d, valid loss %g' % (j, i, loss))

                _ = session.run(self.encode_opts[j], feed_dict={self.x: batch_x, self.y_: batch_y})

                i += 1

            if pretrain_criterion == 'monitor_based':

                tf.train.Saver().restore(session, layer_summaries_dir + '/best.ckpt')

            if summaries_dir is not None:

            return

        injector = BatchInjector(data_x=train_x, data_y=train_y, batch_size=batch_size)

        i = 0

        while _tuning_criterion.continue_learning():

            batch_x, batch_y = injector.next_batch()

            if summaries_dir is not None and (i % summary_interval == 0):

                summary, loss, accuracy = session.run([self.merged, self.loss, self.accuracy],

                                                      feed_dict={self.x: train_x, self.y_: train_y})

                train_writer.add_summary(summary, i)

                logger.info('Fine-Tuning: Step %d, training accuracy %g, loss %g' % (i, accuracy, loss))

                if (test_x is not None) and (test_y is not None):

                    merged, accuracy = session.run([self.merged, self.accuracy],

                                                   feed_dict={self.x: test_x, self.y_: test_y})

                    test_writer.add_summary(merged, i)

                    logger.info('Fine-Tuning: Step %d, test accuracy %g' % (i, accuracy))

                if tuning_criterion == 'monitor_based':

                    merged, accuracy = session.run([self.merged, self.accuracy],

                                                   feed_dict={self.x: valid_x, self.y_: valid_y})

                    valid_writer.add_summary(merged, i)

                    logger.info('Fine-Tuning: Step %d, valid accuracy %g' % (i, accuracy))

            _ = session.run(self.fine_tuning, feed_dict={self.x: batch_x, self.y_: batch_y})

            i += 1

        if tuning_criterion == 'monitor_based':

            tf.train.Saver().restore(session, tuning_summaries_dir + '/best.ckpt')

        if summaries_dir is not None:

        injector = BatchInjector(data_x=x, data_y=y, batch_size=batch_size)

        i = 0

        train_accuracy = 0

        while _criterion.continue_learning():

            batch_x, batch_y = injector.next_batch()

            if summaries_dir is not None and (i % summary_interval == 0):

                summary, loss, accuracy = session.run([self.merged, self.loss, self.accuracy],

                                                      feed_dict={self.x: x, self.y_: y})

                train_writer.add_summary(summary, i)

                train_accuracy = accuracy

                logger.info('Step %d, train_set accuracy %g, loss %g' % (i, accuracy, loss))

                if (test_x is not None) and (test_y is not None):

                    merged, accuracy = session.run([self.merged, self.accuracy],

                                                   feed_dict={self.x: test_x, self.y_: test_y})

                    test_writer.add_summary(merged, i)

                    logger.info('test_set accuracy %g' % accuracy)

                if criterion == 'monitor_based':

                    merged, accuracy = session.run([self.merged, self.accuracy],

                                                   feed_dict={self.x: valid_x, self.y_: valid_y})

                    valid_writer.add_summary(merged, i)

                    logger.info('valid_set accuracy %g' % accuracy)

            loss, accuracy, _ = session.run([self.loss, self.accuracy, self.fit_step],

                                            feed_dict={self.x: batch_x, self.y_: batch_y})

            #logger.info('Step %d, training accuracy %g, loss %g' % (i, accuracy, loss))

            #_ = session.run(self.fit_step, feed_dict={self.x: batch_x, self.y_: batch_y})

            #logger.info('Step %d, training accuracy %g, loss %g' % (i, accuracy, loss))

            i += 1

        if criterion == 'monitor_based':

            tf.train.Saver().restore(session, os.path.join(summaries_dir, 'best.ckpt'))

        logger.debug('Total Epoch: %d, current batch %d', injector.num_epochs, injector.cur_batch)