instalar - tensorflow python

Uso del aprendizaje profundo para predecir la subsecuencia de la secuencia

Question

Tengo un dato que se parece a esto:

Se puede ver here y se ha incluido en el código a continuación. En realidad tengo ~ 7000 muestras (fila), descargables también .

A la tarea se le da antígeno, predecir el epítope correspondiente. Entonces el epítopo es siempre una subcadena exacta de antígeno. Esto es equivalente a la Secuencia de Aprendizaje de Secuencia . Aquí está mi código que se ejecuta en la red neuronal recurrente en Keras. Fue modelado según el example .

Mi pregunta es:

1. ¿Se puede usar RNN, LSTM o GRU para predecir la subsecuencia como se plantea arriba?
2. ¿Cómo puedo mejorar la precisión de mi código?
3. ¿Cómo puedo modificar mi código para que pueda ejecutarse más rápido?

Aquí está mi código de ejecución que dio muy mala puntuación de precisión.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import print_function
import sys
import json
import pandas as pd
from keras.models import Sequential
from keras.engine.training import slice_X
from keras.layers.core import Activation, RepeatVector, Dense
from keras.layers import recurrent, TimeDistributed
import numpy as np
from six.moves import range
class CharacterTable(object):
''''''
Given a set of characters:
+ Encode them to a one hot integer representation
+ Decode the one hot integer representation to their character output
+ Decode a vector of probabilties to their character output
''''''
def __init__(self, chars, maxlen):
self.chars = sorted(set(chars))
self.char_indices = dict((c, i) for i, c in enumerate(self.chars))
self.indices_char = dict((i, c) for i, c in enumerate(self.chars))
self.maxlen = maxlen
def encode(self, C, maxlen=None):
maxlen = maxlen if maxlen else self.maxlen
X = np.zeros((maxlen, len(self.chars)))
for i, c in enumerate(C):
X[i, self.char_indices[c]] = 1
return X
def decode(self, X, calc_argmax=True):
if calc_argmax:
X = X.argmax(axis=-1)
return ''''.join(self.indices_char[x] for x in X)
class colors:
ok = ''/033[92m''
fail = ''/033[91m''
close = ''/033[0m''
INVERT = True
HIDDEN_SIZE = 128
BATCH_SIZE = 64
LAYERS = 3
# Try replacing GRU, or SimpleRNN
RNN = recurrent.LSTM
def main():
"""
Epitope_core = answers
Antigen = questions
"""
epi_antigen_df = pd.io.parsers.read_table("http://dpaste.com/2PZ9WH6.txt")
antigens = epi_antigen_df["Antigen"].tolist()
epitopes = epi_antigen_df["Epitope Core"].tolist()
if INVERT:
antigens = [ x[::-1] for x in antigens]
allchars = "".join(antigens+epitopes)
allchars = list(set(allchars))
aa_chars = "".join(allchars)
sys.stderr.write(aa_chars + "/n")
max_antigen_len = len(max(antigens, key=len))
max_epitope_len = len(max(epitopes, key=len))
X = np.zeros((len(antigens),max_antigen_len, len(aa_chars)),dtype=np.bool)
y = np.zeros((len(epitopes),max_epitope_len, len(aa_chars)),dtype=np.bool)
ctable = CharacterTable(aa_chars, max_antigen_len)
sys.stderr.write("Begin vectorization/n")
for i, antigen in enumerate(antigens):
X[i] = ctable.encode(antigen, maxlen=max_antigen_len)
for i, epitope in enumerate(epitopes):
y[i] = ctable.encode(epitope, maxlen=max_epitope_len)
# Shuffle (X, y) in unison as the later parts of X will almost all be larger digits
indices = np.arange(len(y))
np.random.shuffle(indices)
X = X[indices]
y = y[indices]
# Explicitly set apart 10% for validation data that we never train over
split_at = len(X) - len(X) / 10
(X_train, X_val) = (slice_X(X, 0, split_at), slice_X(X, split_at))
(y_train, y_val) = (y[:split_at], y[split_at:])
sys.stderr.write("Build model/n")
model = Sequential()
# "Encode" the input sequence using an RNN, producing an output of HIDDEN_SIZE
# note: in a situation where your input sequences have a variable length,
# use input_shape=(None, nb_feature).
model.add(RNN(HIDDEN_SIZE, input_shape=(max_antigen_len, len(aa_chars))))
# For the decoder''s input, we repeat the encoded input for each time step
model.add(RepeatVector(max_epitope_len))
# The decoder RNN could be multiple layers stacked or a single layer
for _ in range(LAYERS):
model.add(RNN(HIDDEN_SIZE, return_sequences=True))
# For each of step of the output sequence, decide which character should be chosen
model.add(TimeDistributed(Dense(len(aa_chars))))
model.add(Activation(''softmax''))
model.compile(loss=''categorical_crossentropy'',
optimizer=''adam'',
metrics=[''accuracy''])
# Train the model each generation and show predictions against the validation dataset
for iteration in range(1, 200):
print()
print(''-'' * 50)
print(''Iteration'', iteration)
model.fit(X_train, y_train, batch_size=BATCH_SIZE, nb_epoch=5,
validation_data=(X_val, y_val))
###
# Select 10 samples from the validation set at random so we can visualize errors
for i in range(10):
ind = np.random.randint(0, len(X_val))
rowX, rowy = X_val[np.array([ind])], y_val[np.array([ind])]
preds = model.predict_classes(rowX, verbose=0)
q = ctable.decode(rowX[0])
correct = ctable.decode(rowy[0])
guess = ctable.decode(preds[0], calc_argmax=False)
# print(''Q'', q[::-1] if INVERT else q)
print(''T'', correct)
print(colors.ok + ''☑'' + colors.close if correct == guess else colors.fail + ''☒'' + colors.close, guess)
print(''---'')
if __name__ == ''__main__'':
main()

Answer 1

1. ¿Se puede usar RNN, LSTM o GRU para predecir la subsecuencia como se plantea arriba?

Sí, puedes usar cualquiera de estos. LSTM y GRU son tipos de RNN; si por RNN te refieres a un RNN totalmente conectado , estos se han perdido debido al problema de la desaparición de gradientes ( 1 , 2 ). Debido al número relativamente pequeño de ejemplos en su conjunto de datos, una GRU podría ser preferible a una LSTM debido a su arquitectura más simple.

2. ¿Cómo puedo mejorar la precisión de mi código?

Usted mencionó que los errores de entrenamiento y validación son malos. En general, esto podría deberse a uno de varios factores:

• La tasa de aprendizaje es demasiado baja (no es un problema ya que está usando Adam, un algoritmo de tasa de aprendizaje adaptable por parámetro)
• El modelo es demasiado simple para los datos (no es el problema, ya que tiene un modelo muy complejo y un pequeño conjunto de datos)
• Tiene gradientes de desaparición (probablemente el problema ya que tiene un RNN de 3 capas). Intente reducir el número de capas a 1 (en general, es bueno comenzar haciendo funcionar un modelo simple y luego aumentar la complejidad), y también considerar la búsqueda de hiperparámetros (por ejemplo, un estado oculto de 128 dimensiones puede ser demasiado grande, ¿intente 30? ).

Otra opción, dado que su epítopo es una subcadena de su entrada, es predecir los índices de inicio y finalización del epítope dentro de la secuencia de antígeno (potencialmente normalizada por la longitud de la secuencia del antígeno) en lugar de predecir la subcadena de un carácter a la vez. Esto sería un problema de regresión con dos tareas. Por ejemplo, si el antígeno es FSKIAGLTVT (10 letras de largo) y su epítopo es KIAGL (posiciones 3 a 7, basado en una), entonces la entrada sería FSKIAGLTVT y las salidas serían 0.3 (primera tarea) y 0.7 (segunda tarea) .

Alternativamente, si puede hacer que todos los antígenos tengan la misma longitud (eliminando partes de su conjunto de datos con antígenos cortos y / o cortando los extremos de antígenos largos suponiendo que sabe a priori que el epítope no está cerca de los extremos), puede enmarcarlo como un problema de clasificación con dos tareas (inicio y final) y clases de longitud de secuencia, donde se intenta asignar una probabilidad al antígeno que comienza y termina en cada una de las posiciones.

3. ¿Cómo puedo modificar mi código para que pueda ejecutarse más rápido?

Reducir el número de capas acelerará significativamente tu código. Además, las GRU serán más rápidas que las LSTM debido a su arquitectura más simple. Sin embargo, ambos tipos de redes recurrentes serán más lentas que, por ejemplo, redes convolucionales.

No dude en enviarme un correo electrónico (dirección en mi perfil) si está interesado en una colaboración.