• Search by Module
• Search by Words
• Search Projects

• Java
• Python
• JavaScript
• TypeScript
• C++
• Scala
• Blog

• KATE-master
  • run_wikitag_extractor.py
  • nvdm_doccodes_converter.py
  • construct_movie_review_data.py
  • plot_reuters.py
  • train_vae.py
  • autoencoder
    • datasets
      • wiki10plus.py
      • the20news.py
      • movie_review_data.py
      • wikitag_extractor.py
      • __init__.py
      • reuters.py
    • utils
      • op_utils.py
      • io_utils.py
      • keras_utils.py
      • __init__.py
    • baseline
      • word2vec.py
      • doc2vec.py
      • lda.py
      • __init__.py
      • doc_word2vec.py
    • __init__.py
    • preprocessing
      • preprocessing.py
      • __init__.py
      • patterns
        • english_stopwords.txt
    • core
      • deepae.py
      • vae.py
      • ae.py
      • __init__.py
    • testing
      • eval_word_sim.py
      • regression.py
      • retrieval.py
      • __init__.py
      • visualize.py
      • classifier.py
  • img
  • construct_wiki10plus.py
  • run_doc_retrieval.py
  • LICENSE
  • run_w2v.py
  • legacy_train.py
  • plot.py
  • run_classifier.py
  • get_reuters_labels.py
  • pred.py
  • construct_reuters.py
  • plot_DBN.py
  • train.py
  • run_doc_word2vec.py
  • __init__.py
  • README.md
  • run_regression.py
  • run_doc2vec.py
  • corpus2libsvm.py
  • requirements.txt
  • run_clf.py
  • docnade_doccodes_converter.py
  • run_lda.py
  • .gitignore
  • pred_vae.py
  • run_xml2text_wiki10puls.py
  • legacy_pred.py
  • get_wiki10plus_labels.py
  • construct_20news.py
  • financial_insights.py
  • corpus2dbnformat.py

'''
Created on Nov, 2016

@author: hugo

'''
from __future__ import absolute_import
from os import path
import numpy as np
from keras.layers import Input, Dense, Lambda, Dropout
from keras.models import Model
from keras.optimizers import Adadelta, Adam, Adagrad
from keras.models import load_model
from keras import regularizers
import keras.backend as K
from keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
from keras.layers.core import Activation
# from keras.layers.normalization import BatchNormalization

from ..utils.keras_utils import Dense_tied, weighted_binary_crossentropy, KCompetitive
from ..utils.io_utils import dump_json, load_json

class DeepAutoEncoder(object):
    """Deep AutoEncoder for topic modeling.

        Parameters
        ----------
        dim : dimensionality of encoding space.

        nb_epoch :

        batch_size :

        """

    def __init__(self, input_size, dim, comp_topk=None, \
        weights_file=None, model_save_path='./'):
        self.input_size = input_size
        self.dim = dim
        self.comp_topk = comp_topk
        self.model_save_path = model_save_path

        self.build(weights_file)

    def build(self, weights_file=None):
        h1_dim = 256

        # this is our input placeholder
        input_layer = Input(shape=(self.input_size,))

        # "encoded" is the encoded representation of the input
        h1_layer = Dense(h1_dim, init='glorot_normal', activation='tanh')
        encoded_layer = Dense(self.dim, init='glorot_normal', activation='tanh')

        encoded = h1_layer(input_layer)

        if self.comp_topk:
            encoded = KCompetitive(self.comp_topk)(encoded)
            print 'add k-competitive layer'

        encoded = encoded_layer(encoded)
        if self.comp_topk:
            encoded = KCompetitive(self.comp_topk)(encoded)
            print 'add k-competitive layer'

        # "decoded" is the lossy reconstruction of the input
        decoder_layer = Dense_tied(h1_dim, init='glorot_normal', activation='tanh', tied_to=encoded_layer)
        rev_h1_layer = Dense_tied(self.input_size, init='glorot_normal', activation='sigmoid', tied_to=h1_layer)
        decoded = decoder_layer(encoded)

        if self.comp_topk:
            decoded = KCompetitive(self.comp_topk)(decoded)
            print 'add k-competitive layer'

        decoded = rev_h1_layer(decoded)

        # this model maps an input to its reconstruction
        self.autoencoder = Model(input=input_layer, output=decoded)

        # this model maps an input to its encoded representation
        self.encoder = Model(input=input_layer, output=encoded)

        # create a placeholder for an encoded (32-dimensional) input
        encoded_input = Input(shape=(self.dim,))

        # create the decoder model
        self.decoder = Model(input=encoded_input, output=rev_h1_layer(decoder_layer(encoded_input)))

        if not weights_file is None:
            self.autoencoder.load_weights(weights_file, by_name=True)
            print 'Loaded pretrained weights'

    def fit(self, train_X, val_X, nb_epoch=50, batch_size=100, feature_weights=None):
        print 'Training autoencoder'
        optimizer = Adadelta(lr=1.5)
        # optimizer = Adam()
        # optimizer = Adagrad()
        if feature_weights is None:
            self.autoencoder.compile(optimizer=optimizer, loss='binary_crossentropy') # kld, binary_crossentropy, mse
        else:
            print 'Using weighted loss'
            self.autoencoder.compile(optimizer=optimizer, loss=weighted_binary_crossentropy(feature_weights)) # kld, binary_crossentropy, mse

        self.autoencoder.fit(train_X[0], train_X[1],
                        nb_epoch=nb_epoch,
                        batch_size=batch_size,
                        shuffle=True,
                        validation_data=(val_X[0], val_X[1]),
                        callbacks=[
                                    ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=3, min_lr=0.01),
                                    EarlyStopping(monitor='val_loss', min_delta=1e-5, patience=5, verbose=1, mode='auto'),
                                    # ModelCheckpoint(self.model_save_path, monitor='val_loss', save_best_only=True, verbose=0),
                        ]
                        )

        return self