Python-сообщество

 from scipy import sin, rand, arange
from pybrain3.datasets            import SequentialDataSet
from pybrain3.structure.modules   import LSTMLayer, SigmoidLayer
from pybrain3.supervised          import BackpropTrainer
from pybrain3.tools.validation    import ModuleValidator, SequenceHelper
from pybrain3.tools.shortcuts     import buildNetwork
from pybrain3.datasets import SupervisedDataSet
from pybrain3.supervised.trainers import RPropMinusTrainer
from pybrain3.structure import SoftmaxLayer
import pickle
import numpy as np
def get_batches(arr, n_seqs, n_steps):
    '''Создаем генератор, который возвращает пакеты размером
       n_seqs x n_steps из массива arr.
       
       Аргументы
       ---------
       arr: Массив, из которого получаем пакеты
       n_seqs: Batch size, количество последовательностей в пакете
       n_steps: Sequence length, сколько "шагов" делаем в пакете
    '''
    # Считаем количество символов на пакет и количество пакетов, которое можем сформировать
    characters_per_batch = n_seqs * n_steps
    n_batches = len(arr)//characters_per_batch
    
    # Сохраняем в массиве только символы, которые позволяют сформировать целое число пакетов
    arr = arr[:n_batches * characters_per_batch]
    
    # Делаем reshape 1D -> 2D, используя n_seqs как число строк, как на картинке
    arr = arr.reshape((n_seqs, -1))
    
    for n in range(0, arr.shape[1], n_steps):
        # пакет данных, который будет подаваться на вход сети
        x = arr[:, n:n+n_steps]
        # целевой пакет, с которым будем сравнивать предсказание, получаем сдвиганием "x" на один символ вперед
        y = np.zeros_like(x)
        y[:, :-1], y[:, -1] = x[:, 1:], x[:, 0]
        yield x, y
# колличество входов/выходов
nv1=20
with open('1.txt', 'r') as f:
    text=f.read()
vocab = sorted(set(text))
vocab_to_int = {c: i for i, c in enumerate(vocab)}
int_to_vocab = dict(enumerate(vocab))
encoded = np.array([vocab_to_int[c] for c in text], dtype=np.int32)
print(encoded)
nv2=round((len(encoded)/nv1)-1)
nmax=np.max(encoded)
encoded = encoded/nmax
print(encoded)
#rnn = buildNetwork(nv1, nv1, nv1,
#                   hiddenclass=LSTMLayer,
#                   outclass=SigmoidLayer,
#                   recurrent=True)
rnn = buildNetwork(nv1, nv1, nv1,
                   hiddenclass=LSTMLayer,
                   outclass=SoftmaxLayer,
                   recurrent=True)
ds = SupervisedDataSet(nv1,nv1)
bach=get_batches(encoded,1,nv1)
for i in range(nv2):
    x,y = next(bach)
    #print('++Data++')
    #print(x)
    #print(y)
    ds.addSample(x,y)
trainer = BackpropTrainer(rnn)
#trainer = RPropMinusTrainer(rnn)
trainer.setData(ds)
nmas = np.array([encoded[c] for c in range(nv1)])
print(nmas)
ab = rnn.activate(nmas)
for i in range(len(nmas)):
    print(int_to_vocab[round(nmas[i]*nmax)])
print('')
# 20*10 = 2000 цыклов)))
for zxc in range(20):
    trainer.trainEpochs(10)
    for i in range(100):
        print(int_to_vocab[round(ab[0]*nmax)],end="")
        ab = rnn.activate(ab)
    print('')
#fileo=open('pybrainnet','w')
with open('pybrainnet', 'wb') as fileo:
    pickle.dump(rnn,fileo)
fileo.close()