Блог

Я пытаюсь генерировать новые сигналы, такие как мой набор данных из 29000 сигналов с 2000 образцами. Я использую BiLSTM-CNN для обучения своей модели. Но после тренировки потеря составит 0, а точность-0. Я разделил данные на пакетированные и перемешанные тестовые и обучающие наборы. я попытался изменить структуру модели, но результат тот же. Вы не могли бы мне помочь?

Мой код выглядит следующим образом:

 import tensorflow as tf
from tensorflow.keras import layers, regularizers
import matplotlib.pyplot as plt
import numpy as np
import random

from IPython import display
from tqdm import tqdm

from scipy.io import loadmat

def prepare_data(dim):
    data = loadmat('finaliconzeri.mat')
    data = data['car_finale']
    data = np.reshape(data, (data.shape[0], 1, data.shape[1]))
    print('Data shape:', data.shape)

    #shape is [29000 1 2000]
    data = np.array(data, dtype='float64')
    train_size = int(data.shape[0] * 0.9)
    test_size = data.shape[0] - train_size
    print(train_size, test_size)

    train_dataset = tf.data.Dataset.from_tensor_slices(data[:train_size]).shuffle(train_size).batch(BATCH_SIZE)
    test_dataset  = tf.data.Dataset.from_tensor_slices(data[train_size:]).shuffle(test_size).batch(4)

    seed = tf.random.normal(dim)
    
    return seed, train_dataset, test_dataset
def generatore():
    model = tf.keras.Sequential()
    model.add(layers.InputLayer(input_shape=(400,10),dtype=tf.dtypes.float64))
    model.add(layers.Bidirectional(layers.LSTM(100,return_sequences=True),dtype='float64'))
    model.add(layers.Conv1DTranspose(filters=90, kernel_size=5, strides=5, padding='valid',activation='relu'))
    model.add(layers.Dropout(0.5))
    model.add(layers.Dense(1,activation='tanh'))
    model.add(layers.Permute((2, 1)))
    
    return model


def discriminatore():
    model = tf.keras.Sequential()
   
    model.add(layers.InputLayer(input_shape=(1,2000),dtype=tf.dtypes.float64))
    model.add(layers.Permute((2, 1)))
    
    model.add(layers.Conv1D(filters=10, kernel_size=90, strides=5, padding='valid',activation='relu',dtype='float64'))
    model.add(layers.MaxPool1D(pool_size=36,strides=3,dtype='float64'))
    model.add(layers.Conv1D(filters=5, kernel_size=24, strides=3, padding='valid',activation='relu'))
    model.add(layers.MaxPool1D(pool_size=16,strides=3,dtype='float64'))
    model.add(layers.Flatten(dtype='float64'))
    model.add(layers.Dense(25,dtype='float64'))
    model.add(layers.Softmax(dtype='float64'))
    model.add(layers.Dense(1,activation='sigmoid',dtype='float64'))
    return model

generator     = generatore()
discriminator = discriminatore()

disc_log_dir = 'logs/gradient_tape/disc_loss'
disc_losses = tf.keras.metrics.Mean('disc_loss', dtype=tf.float64)
disc_losses_list = []

fake_disc_accuracy = tf.keras.metrics.BinaryAccuracy('fake_disc_accuracy')
real_disc_accuracy = tf.keras.metrics.BinaryAccuracy('real_disc_accuracy')
fake_disc_accuracy_list, real_disc_accuracy_list = [], []

gen_log_dir = 'logs/gradient_tape/gen_loss'
gen_losses = tf.keras.metrics.Mean('gen_loss', dtype=tf.float64)
gen_losses_list = []


cross_entropy = tf.keras.losses.BinaryCrossentropy()

def discriminator_loss(real_output, fake_output):
    real_loss = cross_entropy(tf.ones_like(real_output), real_output)
    fake_loss = cross_entropy(tf.zeros_like(fake_output), fake_output)
    total_loss = real_loss   fake_loss
    return total_loss

def generator_loss(fake_output):
    return cross_entropy(tf.ones_like(fake_output), fake_output)

generator_optimizer = tf.keras.optimizers.Adam()
discriminator_optimizer = tf.keras.optimizers.Adam()

disc_steps = 1

@tf.function
def train_step(real_sig, dim):
    noise = tf.random.normal(dim)

    for i in range(disc_steps):
        with tf.GradientTape() as disc_tape:
            generated_sig = generator(noise, training=True)

            real_output = discriminator(real_sig, training=True)
            fake_output = discriminator(generated_sig, training=True)

            disc_loss = discriminator_loss(real_output, fake_output)
        
        gradients_of_discriminator = disc_tape.gradient(disc_loss, discriminator.trainable_variables)
        discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator, discriminator.trainable_variables))
  
    with tf.GradientTape() as gen_tape:
        generated_sig = generator(noise, training=True)
        fake_output = discriminator(generated_sig, training=True)

        gen_loss = generator_loss(fake_output)
    
    gradients_of_generator = gen_tape.gradient(gen_loss, generator.trainable_variables)
    generator_optimizer.apply_gradients(zip(gradients_of_generator, generator.trainable_variables))

def train(dataset, epochs, dim):
    for epoch in tqdm(range(epochs)):
    
        for batch in dataset:
            train_step(batch, dim)
            
        disc_losses_list.append(disc_losses.result().numpy())
        gen_losses_list.append(gen_losses.result().numpy())
        
        fake_disc_accuracy_list.append(fake_disc_accuracy.result().numpy())
        real_disc_accuracy_list.append(real_disc_accuracy.result().numpy())

    
BATCH_SIZE = 8
noise_dim = [BATCH_SIZE,400,10]

seed, train_dataset, test_dataset = prepare_data(noise_dim)
train(train_dataset, 100, noise_dim)