Hier is een voorbeeld van een TensorFlow-model met een aangepaste verliesfunctie voor uw taak: ```python import tensorflow as tf from tensorflow.keras import layers, models import numpy as np # Aangepaste verliesfunctie die valse negatieven zwaarder straft class ZwaarGestraffeFoutNegatievenVerlies(tf.keras.losses.Loss): def __init__(self, straf_factor=2.0, naam="aangepast_verlies"): super().__init__(name=naam) self.straf_factor = straf_factor # Factor om valse negatieven zwaarder te straffen def call(self, y_true, y_pred): # Basis binaire cross-entropy bce = tf.keras.losses.binary_crossentropy(y_true, y_pred) # Extra straf voor valse negatieven (waar y_true=1 maar y_pred laag) valse_negatieven_straf = tf.where( (y_true == 1) & (y_pred < 0.5), self.straf_factor * bce, bce ) return tf.reduce_mean(valse_negatieven_straf) # Modelarchitectuur def create_model(input_shape): model = models.Sequential([ # Eerste convolutionele laag layers.Conv1D(32, 3, activation='relu', input_shape=input_shape), layers.MaxPooling1D(2), layers.BatchNormalization(), # Tweede convolutionele laag layers.Conv1D(64, 3, activation='relu'), layers.MaxPooling1D(2), layers.Dropout(0.3), # Derde convolutionele laag layers.Conv1D(128, 3, activation='relu'), layers.MaxPooling1D(2), layers.Dropout(0.4), # Flatten naar dense lagen layers.Flatten(), # Eerste dense laag layers.Dense(128, activation='relu'), layers.Dropout(0.5), # Tweede dense laag layers.Dense(64, activation='relu'), layers.Dropout(0.3), # Output laag layers.Dense(1, activation='sigmoid') ]) return model # Voorbeeld gebruik input_shape = (uw_input_dimensie,) # Vervang met uw daadwerkelijke input vorm model = create_model(input_shape) # Compile model met aangepaste verliesfunctie model.compile( optimizer='adam', loss=ZwaarGestraffeFoutNegatievenVerlies(straf_factor=3.0), # Pas straf_factor aan naar behoefte metrics=['accuracy', tf.keras.metrics.Precision(), tf.keras.metrics.Recall()] ) # Class gewichten voor onbalans (optioneel, maar aanbevolen) class_gewichten = {0: 1.0, 1: 10.0} # Pas aan op basis van uw dataset verhouding # Model training (voorbeeld) # model.fit(X_train, y_train, # epochs=50, # batch_size=32, # validation_data=(X_val, y_val), # class_weight=class_gewichten) ``` **Aanvullende aanbevelingen:** 1. **Data preprocessing**: Normaliseer uw kenmerken en overweeg SMOTE of oversampling voor de minderheidsklasse 2. **Class weights**: Gebruik class weights in combinatie met uw aangepaste verliesfunctie: ```python from sklearn.utils.class_weight import compute_class_weight class_weights = compute_class_weight('balanced', classes=np.unique(y_train), y=y_train) ``` 3. **Monitoring**: Track naast accuracy ook precision, recall en F1-score: ```python metrics = [ 'accuracy', tf.keras.metrics.Precision(name='precision'), tf.keras.metrics.Recall(name='recall'), tf.keras.metrics.AUC(name='auc') ] ``` 4. **Early stopping**: Implementeer early stopping om overfitting te voorkomen: ```python early_stopping = tf.keras.callbacks.EarlyStopping( monitor='val_recall', # Focus op recall voor valse negatieven patience=10, mode='max' ) ``` Pas de `straf_factor` aan op basis van uw validatieresultaten om de optimale balans tussen precision en recall te vinden.