Skip to content
The Chat Archive
gpt-4-0314· OpenAI WildChat-4.8M (AI2)

Berikut adalah kode yang telah dimodifikasi dengan menambahkan Gaussian Process…

  1. User

    Berikut adalah kode yang telah dimodifikasi dengan menambahkan Gaussian Process Optimization untuk mengoptimalkan jumlah unit LSTM, unit Conv1D serta bagian pada model keras untuk mendapatkan model dengan akurasi terbaik. Di akhir, kode juga mengekspor model terbaik ke file .h5 dan file .pkl (pickle). " import pickle import pandas as pd import numpy as np from keras.preprocessing.text import Tokenizer from keras.utils import pad_sequences from keras.models import Sequential from keras.layers import Embedding, LSTM, Dense, Dropout, Conv1D, MaxPooling1D from keras.layers import Flatten from keras.utils import to_categorical from sklearn.model_selection import train_test_split from sklearn.metrics import accuracy_score, classification_report from skopt import gp_minimize from skopt.space import Integer from skopt.utils import use_named_args

    Membaca dataset

    data_list = pickle.load(open(‘filtered_pre_processed_berita_2_joined_done.pkl’, ‘rb’)) data = pd.DataFrame(data_list, columns=[‘judul’, ‘isi’, ‘pre_processed’, ‘Label’]) data[‘Isi Berita’] = data[‘pre_processed’]

    Tokenisasi dan Padding

    max_words = 10000 # mengurangi jumlah kata maksimum max_len = 500 # mengurangi panjang input tokenizer = Tokenizer(num_words=max_words) tokenizer.fit_on_texts(data[‘Isi Berita’]) sequences = tokenizer.texts_to_sequences(data[‘Isi Berita’]) X = pad_sequences(sequences, maxlen=max_len) y = to_categorical(data[‘Label’].astype(‘category’).cat.codes)

    Membagi data menjadi data latih dan data uji

    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)

    Definisi rentang hyperparameter

    space = [Integer(32, 128, name=‘LSTM_units’), Integer(32, 128, name=‘Conv1D_units’)]

    @use_named_args(space) def objective(**params): # Membuat model LSTM-CNN dengan jumlah unit yang lebih kecil model = Sequential() model.add(Embedding(max_words, 64, input_length=max_len)) model.add(LSTM(params[‘LSTM_units’], return_sequences=True, dropout=0.2)) model.add(Conv1D(params[‘Conv1D_units’], 5, activation=‘relu’)) model.add(MaxPooling1D(pool_size=4)) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(32, activation=‘relu’)) model.add(Dense(3, activation=‘softmax’))

    # Menyusun model
    model.compile(optimizer=‘adam’, loss=‘categorical_crossentropy’, metrics=[‘accuracy’])
    
    # Melatih model dengan jumlah epoch yang lebih kecil
    model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=5, batch_size=128, verbose=0)
    
    # Mengevaluasi model
    y_pred = model.predict(X_test)
    y_pred = np.argmax(y_pred, axis=1)
    y_true = np.argmax(y_test, axis=1)
    
    # Menghitung akurasi
    accuracy = accuracy_score(y_true, y_pred)
    print(f"Parameter dicoba: {params} -> Akurasi: {accuracy}")
    
    return -accuracy  # untuk maksimisasi
    

    res_gp = gp_minimize(objective, space, n_calls=10, random_state=0)

    Menampilkan hasil

    print(“Best parameters (minimizing negative accuracy):”) print(res_gp.x, -res_gp.fun)

    Menyimpan model terbaik

    best_LSTM_units, best_Conv1D_units = res_gp.x

    Membangun dan melatih model terbaik

    best_model = Sequential() best_model.add(Embedding(max_words, 64, input_length=max_len)) best_model.add(LSTM(best_LSTM_units, return_sequences=True, dropout=0.2)) best_model.add(Conv1D(best_Conv1D_units, 5, activation=‘relu’)) best_model.add(MaxPooling1D(pool_size=4)) best_model.add(Dropout(0.25)) best_model.add(Flatten()) best_model.add(Dense(32, activation=‘relu’)) best_model.add(Dense(3, activation=‘softmax’)) best_model.compile(optimizer=‘adam’, loss=‘categorical_crossentropy’, metrics=[‘accuracy’]) best_model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=5, batch_size=128)

    Menyimpan model terbaik ke file

    best_model.save(‘best_lstm_cnn_model.h5’) pickle.dump(tokenizer, open(‘tokenizer.pkl’, ‘wb’)) " Modifikasi kode tersebut dengan mengubahnya menjadi menggunakan Bayesian Optimization dengan Gaussian Process untuk mengoptimalkan parameter analisis sentimen CNN-LSTM agar mendapatkan akurasi terbaik. Parameter yang dicoba-coba adalah:

    untuk LSTM layer:

    1. Jumlah unit LSTM
    2. Jumlah lapisan LSTM
    3. Dimensi Embedding
    4. Learning rate
    5. Dropout rate
    6. Ukuran batch
    7. Optimizer (misalnya SGD, Adam, RMSprop)
    8. Ukuran vocab
    9. Panjang maksimum urutan
    10. Fungsi loss (misalnya binary_crossentropy atau categorical_crossentropy)

    untuk CNN layer:

    1. Ukuran filter (kernel): Ukuran filter yang digunakan dalam layer konvolusi.
    2. Stride dan padding: Ukuran stride dan padding yang digunakan dalam operasi konvolusi.
    3. Fungsi aktivasi: Jenis fungsi aktivasi yang digunakan dalam model, seperti ReLU, tanh, sigmoid, atau Leaky ReLU.
    4. Parameter pooling: Ukuran pooling dan jenis pooling, seperti max pooling atau average pooling.
    5. Dropout rate: Tingkat dropout yang digunakan dalam layer dropout model.
    6. Learning rate: Parameter learning rate yang digunakan dalam metode optimasi.
    7. Ukuran batch: Ukuran batch saat melatih model.
    8. Menggunakan regularisasi atau tidak: Menggunakan regularisasi L1, L2, atau tidak sama sekali.
    9. Weight decay: Nilai dari weight decay (regularisasi) jika digunakan.
    10. Optimizer: Jenis optimizer yang digunakan, seperti Gradient Descent, Adam, Adagrad, atau RMSProp
  2. Assistant

    Berikut adalah kode yang telah dimodifikasi dengan menambahkan Bayesian Optimization dengan Gaussian Process untuk mengoptimalkan parameter analisis sentimen CNN-LSTM agar mendapatkan akurasi terbaik:

    import pickle
    import pandas as pd
    import numpy as np
    from keras.preprocessing.text import Tokenizer
    from keras.models import Sequential
    from keras.layers import Embedding, LSTM, Dense, Dropout, Conv1D, MaxPooling1D, Flatten
    from keras.optimizers import SGD, Adam, RMSprop
    from keras.losses import binary_crossentropy, categorical_crossentropy
    from keras.utils import to_categorical
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import accuracy_score, classification_report
    from skopt import gp_minimize
    from skopt.space import Real, Integer, Categorical
    
    # Membaca dataset
    data_list = pickle.load(open('filtered_pre_processed_berita_2_joined_done.pkl', 'rb'))
    data = pd.DataFrame(data_list, columns=['judul', 'isi', 'pre_processed', 'Label'])
    data['Isi Berita'] = data['pre_processed']
    
    # Definisi rentang hyperparameter
    space  = [
        Integer(32, 128, name='LSTM_units'),
        Integer(1, 3, name='LSTM_layers'),
        Integer(32, 128, name='Embedding_dim'),
        Real(1e-4, 1e-2, name='Learning_rate'),
        Real(0.1, 0.6, name='Dropout_rate'),
        Integer(32, 128, name='Batch_size'),
        Categorical([SGD, Adam, RMSprop], name='Optimizer'),
        Integer(5000, 10000, name='Vocab_size'),
        Integer(200, 500, name='Max_sequence_length'),
        Categorical([binary_crossentropy, categorical_crossentropy], name='Loss_function'),
        Integer(32, 128, name='Conv1D_units'),
        Integer(3, 7, name='Kernel_size'),
        Integer(1, 2, name='Stride'),
        Categorical(['valid', 'same'], name='Conv1D_padding'),
        Integer(2, 6, name='Pooling_size'),
        Categorical(['max', 'average'], name='Pooling_type')
    ]
    
    @use_named_args(space)
    def objective(**params):
        # Tokenisasi dan Padding
        max_words = params['Vocab_size']
        max_len = params['Max_sequence_length']
        tokenizer = Tokenizer(num_words=max_words)
        tokenizer.fit_on_texts(data['Isi Berita'])
        sequences = tokenizer.texts_to_sequences(data['Isi Berita'])
        X = pad_sequences(sequences, maxlen=max_len)
        y = to_categorical(data['Label'].astype('category').cat.codes)
    
        # Membagi data menjadi data latih dan data uji
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)
    
        # Membuat model LSTM-CNN
        model = Sequential()
        model.add(Embedding(max_words, params['Embedding_dim'], input_length=max_len))
        
        # Menambahkan layer LSTM
        for _ in range(params['LSTM_layers']):
            model.add(LSTM(params['LSTM_units'], return_sequences=True, dropout=params['Dropout_rate']))
        
        # Menambahkan layer CNN
        model.add(Conv1D(params['Conv1D_units'], params['Kernel_size'], strides=params['Stride'], padding=params['Conv1D_padding'], activation='relu'))
        
        # Menambahkan layer pooling
        if params['Pooling_type'] == 'max':
            model.add(MaxPooling1D(pool_size=params['Pooling_size']))
        else:
            model.add(AveragePooling1D(pool_size=params['Pooling_size']))
            
        model.add(Dropout(params['Dropout_rate']))
        model.add(Flatten())
        model.add(Dense(32, activation='relu'))
        model.add(Dense(3, activation='softmax'))
    
        # Menyusun model
        model.compile(optimizer=params['Optimizer'](lr=params['Learning_rate']), loss=params['Loss_function'], metrics=['accuracy'])
    
        # Melatih model dengan jumlah epoch yang lebih kecil
        model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=5, batch_size=params['Batch_size'], verbose=0)
    
        # Mengevaluasi model
        y_pred = model.predict(X_test)
        y_pred = np.argmax(y_pred, axis=1)
        y_true = np.argmax(y_test, axis=1)
    
        # Menghitung akurasi
        accuracy = accuracy_score(y_true, y_pred)
        print(f"Parameter dicoba: {params} -> Akurasi: {accuracy}")
    
        return -accuracy  # untuk maksimisasi
    
    res_gp = gp_minimize(objective, space, n_calls=30, random_state=0)
    
    # Menampilkan hasil
    print("Best parameters (minimizing negative accuracy):")
    print(res_gp.x, -res_gp.fun)
    

    Termin penjelasan: Kode ini menggunakan Scikit-optimize mengoptimalkan parameter CNN-LSTM menggunakan proses Gaussian (GP). Parameter yang dioptimalkan mencakup jumlah unit LSTM, jumlah lapisan LSTM, ukuran batch, dan banyak lagi seperti yang dijelaskan dalam list space. Objective function menggunakan akurasi sebagai metrik evaluasi.

    Untuk menguji model terbaik yang ditemukan oleh GP, Anda dapat menggunakannya pada data uji atau validasi lain yang tersedia.

    Untuk menyederhanakan kode, Anda mungkin perlu menghilangkan atau menggabungkan beberapa parameter atau bahkan mengurangi jumlah panggilan.