Adicionando rede neural e rota

api/Neural_Network2.py

@@ -1,4 +1,5 @@
 import csv
+import json
 import re
 import string
 import os
@@ -21,46 +22,58 @@ def preprocess_text(text):
  text = re.sub('\w*\d\w*', '', text)
  return text
 
-def create_and_train_model(train_texts, train_labels, epochs=5):
+def create_and_train_model(train_texts, train_labels,name, epochs=5):
+ # Cria um DataFrame do Pandas com os textos e rótulos de treino
  train_df = pd.DataFrame({'text': train_texts, 'label': train_labels})
+ # Aplica o pré-processamento aos textos
  train_df['text'] = train_df['text'].apply(preprocess_text)
 
+ # Cria um diretório para armazenar os textos de treino como arquivos individuais
  output_directory = 'arquivos_texto_treino_nn'
  os.makedirs(output_directory, exist_ok=True)
 
+ # Escreve cada texto em um arquivo separado dentro do diretório criado
  for index, row in train_df.iterrows():
  filename = os.path.join(output_directory, f'texto_{index}.txt')
  with open(filename, 'w', encoding='utf-8') as file:
  file.write(row['text'])
 
+ # Diretório de treino para o modelo
  treino_dir = output_directory
 
+ # Cria um conjunto de dados de texto usando a API de conjuntos de dados do TensorFlow
  train_dataset = tf.keras.utils.text_dataset_from_directory(
  treino_dir,
  batch_size=32,
  shuffle=True,
  )
 
+ # Parâmetros do modelo
  max_features = 20000
  embedding_dim = 128
  sequence_length = 500
 
+ # Cria uma camada de vetorização de texto
  vectorize_layer = TextVectorization(
  max_tokens=max_features,
  output_mode="int",
  output_sequence_length=sequence_length,
  )
 
+ # Adapta a camada de vetorização ao conjunto de dados de texto
  text_ds = train_dataset.map(lambda x, y: x)
  vectorize_layer.adapt(text_ds)
 
+ # Função para vetorizar o texto e manter os rótulos
  def vectorize_text(text, label):
  text = tf.expand_dims(text, -1)
  return vectorize_layer(text), label
 
+ # Aplica a vetorização ao conjunto de dados de treino
  train_ds = train_dataset.map(vectorize_text)
  train_ds = train_ds.cache().prefetch(buffer_size=10)
 
+ # Define a arquitetura do modelo
  inputs = tf.keras.Input(shape=(None,), dtype="int64")
  x = layers.Embedding(max_features, embedding_dim)(inputs)
  x = layers.Dropout(0.5)(x)
@@ -71,9 +84,60 @@ def vectorize_text(text, label):
  x = layers.Dropout(0.5)(x)
  predictions = layers.Dense(1, activation="sigmoid", name="predictions")(x)
 
+ # Cria e compila o modelo
  model = tf.keras.Model(inputs, predictions)
-
  model.compile(loss="binary_crossentropy", optimizer="adam", metrics=["accuracy"])
- model.fit(train_ds, epochs=epochs)
 
- return model
+ # Treina o modelo
+ history = model.fit(train_ds, epochs=epochs)
+ # Nome do arquivo
+ name = f"nn_{name}.pkl"
+ # Saving the model
+ with open(name, "wb") as model_file:
+ pickle.dump(model, model_file) 
+
+ # Obtém estatísticas do treinamento
+ training_stats = {
+ "loss": history.history['loss'],
+ "accuracy": history.history['accuracy']
+ }
+
+ # Retorna estatísticas como JSON
+ return json.dumps(training_stats)
+
+'''
+Com o nome do arquivo podemos fazer por exemplo:
+
+saved_model_filename = Neural_Network(texts_train, labels_train)
+
+Carregar o modelo treinado a partir do arquivo:
+with open(saved_model_filename, "rb") as model_file:
+ loaded_model = pickle.load(model_file)
+
+Agora, podemos usar loaded_model para fazer previsões, por exemplo:
+predictions = loaded_model.predict(new_texts)
+
+'''
+'''
+TESTE:
+
+df_true = pd.read_csv("Linguifai/api/training_df/True.csv")
+df_fake = pd.read_csv("Linguifai/api/training_df/Fake.csv")
+
+
+df_fake = df_fake.drop(['title', 'subject', 'date'], axis=1)
+df_true = df_true.drop(['title', 'subject', 'date'], axis=1)
+
+
+df_fake['text'] = df_fake["text"]
+df_true['text'] = df_true["text"]
+
+df_fake_train = df_fake[:5000]
+df_true_train = df_true[:5000]
+
+textos = df_fake_train['text'].tolist() + df_true_train['text'].tolist()
+labels = [0] * len(df_fake_train) + [1] * len(df_true_train)
+
+create_and_train_model(textos,labels,"Teste")
+
+'''

api/app.py

@@ -1,8 +1,10 @@
 from flask import Flask, jsonify, request
 from flask_cors import CORS
 from DataProcesser import DataProcesser
+from Neural_Network2 import create_and_train_model
 import os
 import nltk
+import pandas as pd
 import json
 nltk.download('wordnet')
 
@@ -46,5 +48,13 @@ def emotions_model():
  result = data_processer.classify_emotions()
  return jsonify({"result": result.to_json()})
 
+@app.route('/neural-network',methods=["POST"])
+def train_model():
+ received_data = request.get_json()
+ selected_data = received_data.get('data')
+ selected_label = received_data.get('label')
+ name = received_data.get('name')
+ return create_and_train_model(selected_data,selected_label,name) 
+
 if __name__ == '__main__':
  app.run(host='0.0.0.0', port=5000, debug=True)