import lasagne
import theano
import theano.tensor as T
from lxml import etree
from sklearn.feature_extraction.text import CountVectorizer

file1='bank_train_2016.xml'
file2='banks_test_etalon.xml'

def parse(filename):
    X = []
    y=[]
    tree = etree.parse(filename)
    banknames=['sberbank','vtb','gazprom','alfabank','bankmoskvy','raiffeisen','uralsib','rshb']
    useless=['id','twitid','date']
    aa= tree.xpath('database/table')
    for a in aa:
        for node in a:
         if node.get('name')not in useless:
            if node.get('name') not in banknames:
                X.append(node.text)
            else:
             if node.text != 'NULL':
                    y.append(node.text)
                    break
    return X, y

X_train, y_train =parse(file1)
X_test, y_test =parse(file2)

cv = CountVectorizer()
X_train = cv.fit_transform(X_train)
vocab_size=len(cv.vocabulary_.values())
print(vocab_size)



def build_mlp(input_var=None):
    # Входной слой, определяющий размерность данных
    # (переменный размер minibatch'a, 1 канал, 28 строк и 28 столбов)
    # Мы можем передать тензорную переменную для входных данных,
    # или же она будет создана для нас
    network = lasagne.layers.InputLayer(
        shape=(None, 1, 1, vocab_size),
        input_var=input_var)

    # Полносвязный слой на 800 нейронов и ReLU в качестве нелинейности
    # также инициализируем веса методом, предложенным Xavier Glorot и Yoshua Bengio
    network = lasagne.layers.DenseLayer(
        network,
        num_units=800,
        nonlinearity=lasagne.nonlinearities.rectify,
        W=lasagne.init.GlorotUniform())

    # И ещё один полносвязный слой
    network = lasagne.layers.DenseLayer(
        network,
        num_units=800,
        nonlinearity=lasagne.nonlinearities.rectify)

    # Наконец, добавим классификатор на 10 классов:
    network = lasagne.layers.DenseLayer(
        network,
        num_units=3,
        nonlinearity=lasagne.nonlinearities.softmax)

    return network

input_var = T.tensor4('inputs')
target_var = T.ivector('targets')

# воспользуемся функцией из предыдущего листинга
network = build_mlp(input_var)

# эта функция вернёт нам граф вычислений, соответствующий сети
prediction = lasagne.layers.get_output(network)
# зададим функцию потерь
loss = lasagne.objectives.categorical_crossentropy(prediction, target_var).mean()
# Сюда также можно добавить L1 или L2 регуляризацию, см. lasagne.regularization.

# Этот метод позволит получить список параметров сети
# он также принимает keyword аргумент, позволяющий выбрать параметры по тегу
# наиболее часто употребимые это trainable и regularizable
params = lasagne.layers.get_all_params(network, trainable=True)
# используем метод стохастического градиентного спуска с моментом Нестерова
updates = lasagne.updates.nesterov_momentum(
    loss,
    params,
    learning_rate=0.01,
    momentum=0.9)

# Также создадим выражение для функции потерь на валидации.
# Главное отличие тут заключается в аргументе deterministic=True,
# который отключает dropout
test_prediction = lasagne.layers.get_output(network, deterministic=True)
test_loss = T.nnet.categorical_crossentropy(test_prediction,
                                                        target_var).mean()
# Заодно посчитаем точность классификатора
test_acc = T.mean(
    T.eq(T.argmax(test_prediction, axis=1), target_var),
    dtype=theano.config.floatX)
# скомпилируем функцию для обучения
train = theano.function(
    inputs=[input_var, target_var],
    outputs=loss,
    updates=updates)

# и вторую — для валидации
# оптимизатор Theano тут поймёт, что для вычисления функции потерь и точности
# можно переиспользовать большую часть графа
validate = theano.function(
    inputs=[input_var, target_var],
    outputs=[test_loss, test_acc])

print("| Epoch | Train err | Validation err | Accuracy |  Time  |")
print("|------------------------------------------------------------------------|")

try:
    for epoch in range(100):
            # Каждую эпоху будем проходить по всей обучающей выборке
            train_err = 0
            train_batches = 0
            start_time = time.time()
            for batch in iterate_minibatches(X_train, y_train, 500, shuffle=True):
                inputs, targets = batch
                train_err += train(inputs, targets)
                train_batches += 1

            # И по всей валидационной
            val_err = 0
            val_acc = 0
            val_batches = 0
            for batch in iterate_minibatches(X_val, y_val, 500, shuffle=False):
                inputs, targets = batch
                err, acc = validate(inputs, targets)
                val_err += err
                val_acc += acc
                val_batches += 1

            print("|{:05d} | {:4.5f} | {:16.5f} | {:10.2f} | {:7.2f} |".format
                  (epoch,
                    train_err / train_batches,
                    val_err / val_batches,
                    val_acc / val_batches * 100,
                    time.time() - start_time))
except KeyboardInterrupt:
    print("The training was interrupted on epoch: {}".format(epoch))

# Сохраняем веса
savez('model.npz', *lasagne.layers.get_all_param_values(network))

network = build_mlp()
# И загружаем, когда потребуется:
with np.load('model.npz') as f:
     param_values = [f['arr_%d' % i] for i in range(len(f.files))]
lasagne.layers.set_all_param_values(network, param_values)