<jupyter_start><jupyter_text>Ahora recurrimos al metodo tradicional de codificacion<jupyter_code>def vectorize_sequences(sequences,dimension=10000):
    vector=np.zeros((len(sequences),dimension))
    for i,sequence in enumerate(sequences):
        vector[i,sequence]=1
    return vector    
x_train=vectorize_sequences(train_data)
x_test=vectorize_sequences(test_data)
x_train.shape,x_test.shape
y_train=np.array(train_labels).astype('float32')
y_test=np.array(test_labels).astype('float32')<jupyter_output><empty_output><jupyter_text>Datos listos para procesarlos a una red neuronal<jupyter_code>#invocamos a la red neuronal
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.utils import plot_model
#invocamos la libreria de sklearn
from sklearn.model_selection import train_test_split
x_train,x_val,y_train,y_val=train_test_split(x_train,y_train,test_size=0.2,stratify=y_train)
def generate_model():
    #configuracion del modelo , para este caso usamos 16 neuronas en las dos primeras capas
    model=Sequential()
    model.add(Dense(16,activation='relu',input_shape=(10000,)))
    model.add(Dense(16,activation='relu'))
    model.add(Dense(1,activation='sigmoid'))
    model.compile(optimizer='rmsprop',
             loss='binary_crossentropy',
             metrics=['accuracy']
             )
    return model
model=generate_model()
#ahora nos enfocamos en la configuracion de entrenamiento
history=model.fit(x_train,y_train,epochs=20,batch_size=256,validation_data=(x_val,y_val))

plot_model(model,to_file='comentarios POSTIVOS or NEGATIVOS.png')
#ahora graficamos el desenvolvimiento de nuestros modelos, tanto como en los puntajes de perdida y precision
%matplotlib inline
import matplotlib.pyplot as plt

history.history.keys()
#para los puntajes de perdida
train_loss=history.history['loss']
validation_loss=history.history['val_loss']
#para los puntajes de precision del modelo
train_acc=history.history['accuracy']
validation_acc=history.history['val_accuracy']
#para evaluarlos en funcion de las epocas realizadas
epochs=range(1,len(history.history['accuracy'])+1)
#grafica de evaluacion para los puntajes de perdida
def plot_perdida(epochs,train_loss,validation_loss):
    plt.plot(epochs,train_loss,'go-',label='Train loss')
    plt.plot(epochs,validation_loss,'ro-',label='Validation loss')
    plt.title('Puntaje de perdida en los datos de entrenamiento y validacion')
    plt.xlabel('epochs')
    plt.ylabel('loss')
    plt.legend(loc='best')
    plt.show()
    
plot_perdida(epochs,train_loss,validation_loss)
#grafica de evaluacion para los puntajes de perdida
def plot_precision(epochs,train_acc,validation_acc):
    plt.plot(epochs,train_acc,'go-',label='Train accuracy')
    plt.plot(epochs,validation_acc,'ro-',label='Validation accuracy')
    plt.title('Puntaje de precision en los datos de entrenamiento y validacion')
    plt.xlabel('epochs')
    plt.ylabel('accuracy')
    plt.legend(loc='best')
    plt.show()
plot_precision(epochs,train_acc,validation_acc)
model.save('comentary_classification_overfitting.h5')
#ahora generamos un nuevo modelo con una configuracion de entrenamiento de 3 epochs
model=generate_model()
history=model.fit(x_train,y_train,epochs=3,batch_size=256,validation_data=(x_val,y_val))
#observamos las mejoras luego del reentrenamiento
epochs=range(1,len(history.history['accuracy'])+1)
plot_perdida(epochs,history.history['loss'],history.history['val_loss'])
plot_precision(epochs,history.history['accuracy'],history.history['val_accuracy'])
#ahora validamos el modelo con datos nunca antes vistos
loss,acc=model.evaluate(x_test,y_test)
x_test.shape
y_predict=model.predict(x_test)

y_predict=np.where(y_predict>=0.5,1,0)<jupyter_output><empty_output>
StarcoderdataJupyterStructuredCleanDedup