Bangun prediktor toksisitas berbasis teks yang kuat

Dengan pertumbuhan dan popularitas platform sosial online, orang dapat tetap terhubung lebih dari sebelumnya melalui alat seperti pesan instan. Namun, hal ini menimbulkan kekhawatiran tambahan tentang ucapan beracun, serta intimidasi dunia maya, pelecehan verbal, atau penghinaan. Moderasi konten sangat penting untuk mempromosikan diskusi online yang sehat dan menciptakan lingkungan online yang sehat. Untuk mendeteksi konten bahasa beracun, para peneliti telah mengembangkan pendekatan pemrosesan bahasa alami (NLP) berbasis pembelajaran yang mendalam. Metode terbaru menggunakan model bahasa pra-terlatih berbasis transformator dan mencapai akurasi deteksi toksisitas yang tinggi.

Dalam aplikasi pendeteksian toksisitas dunia nyata, pemfilteran toksisitas sebagian besar digunakan dalam industri terkait keamanan seperti platform game, di mana model terus-menerus ditantang oleh rekayasa sosial dan serangan permusuhan. Akibatnya, menerapkan model deteksi toksisitas NLP berbasis teks secara langsung dapat menimbulkan masalah, dan tindakan pencegahan diperlukan.

Penelitian telah menunjukkan bahwa model jaringan saraf yang dalam tidak membuat prediksi yang akurat saat menghadapi contoh permusuhan. Ada minat yang berkembang dalam menyelidiki kekokohan permusuhan model NLP. Ini telah dilakukan dengan tubuh serangan musuh yang baru dikembangkan yang dirancang untuk mengelabui terjemahan mesin, penjawab pertanyaan, dan sistem klasifikasi teks.

Dalam postingan ini, kami melatih pengklasifikasi bahasa toksisitas berbasis transformator menggunakan Hugging Face, menguji model terlatih pada contoh permusuhan, lalu melakukan pelatihan permusuhan dan menganalisis pengaruhnya terhadap pengklasifikasi toksisitas terlatih.

Ikhtisar solusi

Contoh permusuhan adalah input yang terganggu dengan sengaja, yang bertujuan untuk menyesatkan model machine learning (ML) ke output yang salah. Pada contoh berikut (sumber: https://aclanthology.org/2020.emnlp-demos.16.pdf), dengan hanya mengubah kata “Sempurna” menjadi “Tanpa Noda”, model NLP memberikan prediksi yang benar-benar berlawanan.

Insinyur sosial dapat menggunakan jenis karakteristik model NLP ini untuk mem-bypass sistem penyaringan toksisitas. Untuk membuat model prediksi toksisitas berbasis teks lebih kuat terhadap serangan permusuhan yang disengaja, literatur telah mengembangkan berbagai metode. Dalam posting ini, kami menampilkan salah satunya — pelatihan permusuhan, dan bagaimana hal itu meningkatkan ketahanan permusuhan model prediksi toksisitas teks.

Pelatihan permusuhan

Contoh permusuhan yang berhasil mengungkap kelemahan model ML korban target, karena model tidak dapat secara akurat memprediksi label dari contoh permusuhan ini. Dengan melatih ulang model dengan kombinasi data pelatihan asli dan contoh musuh yang berhasil, model yang dilatih ulang akan lebih kuat terhadap serangan di masa mendatang. Proses ini disebut pelatihan lawan.

Perpustakaan TextAttack Python

TextAttack adalah pustaka Python untuk menghasilkan contoh permusuhan dan melakukan pelatihan permusuhan untuk meningkatkan ketahanan model NLP. Pustaka ini menyediakan implementasi berbagai serangan permusuhan teks canggih dari literatur dan mendukung berbagai model dan kumpulan data. Kode dan tutorialnya tersedia di GitHub.

Dataset

Grafik Tantangan Klasifikasi Komentar Beracun di Kaggle menyediakan sejumlah besar komentar Wikipedia yang telah diberi label oleh penilai manusia untuk perilaku beracun. Jenis toksisitas adalah:

• racun
• parah_toksik
• cabul
• ancaman
• menghina
• identitas_benci

Dalam postingan ini, kami hanya memprediksi toxic kolom. Set kereta berisi 159,571 contoh dengan 144,277 contoh tidak beracun dan 15,294 beracun, dan set pengujian berisi 63,978 contoh dengan 57,888 contoh tidak beracun dan 6,090 beracun. Kami membagi set pengujian menjadi validasi dan set pengujian, yang berisi 31,989 contoh masing-masing dengan 29,028 contoh tidak beracun dan 2,961 beracun. Bagan berikut menggambarkan distribusi data kami.

Untuk tujuan demonstrasi, postingan ini secara acak mengambil sampel 10,000 instans untuk pelatihan, dan 1,000 untuk validasi dan pengujian masing-masing, dengan masing-masing set data seimbang pada kedua kelas. Untuk detailnya, lihat kami buku catatan.

Latih pengklasifikasi bahasa beracun berbasis transformator

Langkah pertama adalah melatih pengklasifikasi bahasa beracun berbasis transformator. Kami menggunakan model bahasa DistilBERT terlatih sebagai dasar dan menyempurnakan model pada kumpulan data pelatihan klasifikasi komentar beracun Jigsaw.

Tokenisasi

Token adalah blok bangunan input bahasa alami. Tokenisasi adalah cara memisahkan sepotong teks menjadi token. Token dapat mengambil beberapa bentuk, baik kata, karakter, atau subkata. Agar model memahami teks input, tokenizer digunakan untuk menyiapkan input untuk model NLP. Beberapa contoh tokenisasi termasuk memisahkan string menjadi string token subword, mengonversi string token menjadi ID, dan menambahkan token baru ke kosa kata.

Dalam kode berikut, kami menggunakan tokenizer DistilBERT yang telah dilatih sebelumnya untuk memproses kumpulan data latih dan uji:

pretrained_model_name_or_path = "distilbert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(pretrained_model_name_or_path)

def preprocess_function(examples):
    result = tokenizer(
        examples["text"], padding="max_length", max_length=128, truncation=True
    )
    return result

train_dataset = train_dataset.map(
    preprocess_function, batched=True, load_from_cache_file=False, num_proc=num_proc
)

valid_dataset = valid_dataset.map(
    preprocess_function, batched=True, load_from_cache_file=False, num_proc=num_proc
)

test_dataset = test_dataset.map(
    preprocess_function, batched=True, load_from_cache_file=False, num_proc=num_proc
)

Untuk setiap teks input, tokenizer DistilBERT menampilkan empat fitur:

• teks - Masukkan teks.
• label – Label keluaran.
• masukan_id – Indeks token urutan input dalam kosakata.
• perhatian_topeng – Topeng untuk menghindari perhatian pada indeks padding token. Nilai topeng yang dipilih adalah [0, 1]:
  • 1 untuk token yang tidak disamarkan.
  • 0 untuk token yang disamarkan.

Sekarang setelah kita memiliki kumpulan data token, langkah selanjutnya adalah melatih pengklasifikasi bahasa beracun biner.

Modeling

Langkah pertama adalah memuat model dasar, yang merupakan model bahasa DistilBERT terlatih. Model ini dimuat dengan kelas Transformers Hugging Face AutoModelForSequenceClassification:

base_model = AutoModelForSequenceClassification.from_pretrained(
    pretrained_model_name_or_path, num_labels=1
)

Kemudian kami menyesuaikan hyperparameter menggunakan class TrainingArguments. Model dilatih dengan ukuran batch 32 pada 10 epoch dengan laju pembelajaran 5e-6 dan langkah pemanasan 500. Model yang dilatih disimpan di model_dir, yang didefinisikan di awal notebook.

training_args = TrainingArguments(
    output_dir=model_dir,
    num_train_epochs=10,
    per_device_train_batch_size=32,
    per_device_eval_batch_size=64,
    warmup_steps=500,
    evaluation_strategy="epoch",
    save_strategy="epoch",
    save_total_limit=5,
    logging_dir=os.path.join(model_dir, "logs"),
    learning_rate=5e-6,
    load_best_model_at_end=True,
    metric_for_best_model="loss",
    disable_tqdm=True,
)

Untuk mengevaluasi kinerja model selama pelatihan, kita perlu menyediakan Trainer dengan fungsi evaluasi. Di sini kami melaporkan akurasi, skor F1, presisi rata-rata, dan skor AUC.

# compute metrics function
def compute_metrics(pred):
    targets = 1 * (pred.label_ids >= 0.5)
    outputs = 1 * (pred.predictions >= 0.5)
    accuracy = metrics.accuracy_score(targets, outputs)
    f1_score_micro = metrics.f1_score(targets, outputs, average="micro")
    f1_score_macro = metrics.f1_score(targets, outputs, average="macro")
    f1_score_weighted = metrics.f1_score(targets, outputs, average="weighted")
    ap_score_micro = metrics.average_precision_score(
        targets, pred.predictions, average="micro"
    )
    ap_score_macro = metrics.average_precision_score(
        targets, pred.predictions, average="macro"
    )
    ap_score_weighted = metrics.average_precision_score(
        targets, pred.predictions, average="weighted"
    )
    auc_score_micro = metrics.roc_auc_score(targets, pred.predictions, average="micro")
    auc_score_macro = metrics.roc_auc_score(targets, pred.predictions, average="macro")
    auc_score_weighted = metrics.roc_auc_score(
        targets, pred.predictions, average="weighted"
    )
    return {
        "accuracy": accuracy,
        "f1_score_micro": f1_score_micro,
        "f1_score_macro": f1_score_macro,
        "f1_score_weighted": f1_score_weighted,
        "ap_score_micro": ap_score_micro,
        "ap_score_macro": ap_score_macro,
        "ap_score_weighted": ap_score_weighted,
        "auc_score_micro": auc_score_micro,
        "auc_score_macro": auc_score_macro,
        "auc_score_weighted": auc_score_weighted,
    }

Grafik Trainer kelas menyediakan API untuk pelatihan lengkap fitur di PyTorch. Mari kita instantiate Trainer dengan menyediakan model dasar, argumen pelatihan, dataset pelatihan dan evaluasi, serta fungsi evaluasi:

trainer = Trainer(
    model=base_model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=valid_dataset,
    compute_metrics=compute_metrics,
)

Setelah Trainer dibuat instance-nya, kita dapat memulai proses pelatihan:

train_result = trainer.train()

Saat proses pelatihan selesai, kami menyimpan tokenizer dan memodelkan artefak secara lokal:

tokenizer.save_pretrained(model_dir)
trainer.save_model(model_dir)

Mengevaluasi ketahanan model

Di bagian ini, kami mencoba menjawab satu pertanyaan: seberapa kuat model pemfilteran toksisitas kami terhadap serangan permusuhan berbasis teks? Untuk menjawab pertanyaan ini, kami memilih resep serangan dari perpustakaan TextAttack dan menggunakannya untuk membuat contoh permusuhan yang terganggu untuk mengelabui model penyaringan toksisitas target kami. Setiap resep serangan menghasilkan contoh adversarial teks dengan mengubah input teks seed menjadi sampel teks yang sedikit diubah, sambil memastikan seed dan teks yang terganggu mengikuti batasan bahasa tertentu (misalnya, semantik diawetkan). Jika contoh yang baru dibuat ini menipu model target ke dalam klasifikasi yang salah, serangan itu berhasil; jika tidak, serangan gagal untuk input seed tersebut.

Kekokohan permusuhan model target dievaluasi melalui metrik Attack Success Rate (ASR). ASR didefinisikan sebagai rasio serangan yang berhasil terhadap semua serangan. Semakin rendah ASR, semakin kuat model terhadap serangan musuh.

Pertama, kami mendefinisikan pembungkus model khusus untuk menyatukan tokenisasi dan prediksi model. Langkah ini juga memastikan keluaran prediksi memenuhi format keluaran yang diperlukan oleh pustaka TextAttack.

class CustomModelWrapper(ModelWrapper):
    def __init__(self, model):
        self.model = model

    def __call__(self, text_input_list):
        device = self.model.device
        encoded_input = tokenizer(
            text_input_list,
            truncation=True,
            padding="max_length",
            max_length=128,
            return_tensors="pt",
        ).to(device)     
        # print(encoded_input.device)

        with torch.no_grad():
            output = self.model(**encoded_input)
        logits = output.logits
        preds = torch.sigmoid(logits)
        preds = preds.squeeze(dim=-1)
        final_preds = torch.stack((1 - preds, preds), dim=1)
        return final_preds

Sekarang kami memuat model terlatih dan membuat pembungkus model khusus menggunakan model terlatih:

trained_model = AutoModelForSequenceClassification.from_pretrained(model_dir)
trained_model = trained_model.to("cuda:0")

model_wrapper = CustomModelWrapper(trained_model)

Menghasilkan serangan

Sekarang kita perlu menyiapkan dataset sebagai seed untuk resep serangan. Di sini kami hanya menggunakan contoh-contoh beracun itu sebagai benih, karena dalam skenario dunia nyata, insinyur sosial sebagian besar akan mencoba mengganggu contoh-contoh beracun untuk mengelabui model penyaringan target sebagai jinak. Serangan bisa memakan waktu untuk menghasilkan; untuk tujuan posting ini, kami secara acak mengambil sampel 1,000 sampel pelatihan beracun untuk diserang.

Kami menghasilkan contoh permusuhan untuk kumpulan data uji dan latih. Kami menggunakan contoh uji permusuhan untuk evaluasi ketahanan dan melatih contoh permusuhan untuk pelatihan permusuhan.

threshold = 0.5
sub_sample_to_attack = 1000
df_train_to_attack = df_train[df_train['labels']==1].sample(sub_sample_to_attack)

## We attack the toxic samples
## Goal is to perturbe toxic samples enough that the model classifies them as Non-toxic
test_dataset_to_attack = textattack.datasets.Dataset(
    [
        (x, 1)
        for x, y in zip(
            test_dataset["text"], 
            test_dataset["labels"], 
        )
        if y > threshold
    ]
)

train_dataset_to_attack = textattack.datasets.Dataset(
    [
        (x, 1)
        for x, y in zip(
            df_train_to_attack["text"],
            df_train_to_attack["labels"],
        )
        if y > threshold
    ]
)

Kemudian kami mendefinisikan fungsi untuk menghasilkan serangan:

def generate_attacks(
    recipe, model_wrapper, dataset_to_attack, num_examples=-1, parallel=False
):
    print(f"The Attack Recipe is: {recipe}")
    if recipe == "textfoolerjin2019":
        attack = TextFoolerJin2019.build(model_wrapper)
    elif recipe == "a2t_yoo_2021":
        attack = A2TYoo2021.build(model_wrapper)
    elif recipe == "Pruthi2019":
        attack = Pruthi2019.build(model_wrapper)
    elif recipe == "TextBuggerLi2018":
        attack = TextBuggerLi2018.build(model_wrapper)
    elif recipe == "DeepWordBugGao2018":
        attack = DeepWordBugGao2018.build(model_wrapper)

    attack_args = textattack.AttackArgs(
        num_examples=num_examples, parallel=parallel, num_workers_per_device=5
    )  
    ## num_examples = -1 means the entire dataset
    attacker = Attacker(attack, dataset_to_attack, attack_args)
    attack_results = attacker.attack_dataset()
    return attack_results

Pilih resep serangan dan hasilkan serangan:

%%time
recipe = 'textfoolerjin2019'
test_attack_results = generate_attacks(recipe, model_wrapper, test_dataset_to_attack, num_examples=-1)
train_attack_results = generate_attacks(recipe, model_wrapper, train_dataset_to_attack, num_examples=-1)

Catat hasil serangan ke dalam bingkai data Pandas:

def log_attack_results(attack_results):
    exception_ids = []
    logger = CSVLogger(color_method="html")
    
    for i in range(len(attack_results)):
        try:
            result = attack_results[i]
            logger.log_attack_result(result)
        except:
            exception_ids.append(i)
    df_attacks = logger.df
    return df_attacks, exception_ids


df_attacks_test, test_exception_ids = log_attack_results(test_attack_results)
df_attacks_train, train_exception_ids = log_attack_results(train_attack_results)

Hasil serangan berisi original_text, perturbed_text, original_output, dan perturbed_output. Ketika perturbed_output adalah kebalikan dari original_output, serangan berhasil.

df_attacks_test.head(2)

display(
    HTML(df_attacks_test[["original_text", "perturbed_text"]].head().to_html(escape=False))
)

Teks merah melambangkan serangan yang berhasil, dan hijau melambangkan serangan yang gagal.

Mengevaluasi ketahanan model melalui ASR

Gunakan kode berikut untuk mengevaluasi ketahanan model:

ASR_test = (
    df_attacks_test.result_type.value_counts()["Successful"]
    / df_attacks_test.result_type.value_counts().sum()
)

ASR_train = (
    df_attacks_train.result_type.value_counts()["Successful"]
    / df_attacks_train.result_type.value_counts().sum()
)

print(f"The Attack Success Rate of the model toward test dataset is {ASR_test*100}%")

print(f"The Attack Success Rate of the model toward train dataset is {ASR_train*100}%")

Ini mengembalikan yang berikut:

The Attack Success Rate of the model toward test dataset is 52.400000000000006%
The Attack Success Rate of the model toward train dataset is 51.1%

Persiapkan serangan yang berhasil

Dengan semua hasil serangan yang tersedia, kami mengambil serangan yang berhasil dari melatih contoh musuh dan menggunakannya untuk melatih ulang model:

# Supply the original labels to the successful attacks
# Here the original labels are all 1, there are also some datasets with fractional labels between 0-1

df_attacks_train = df_attacks_train[["perturbed_text", "result_type"]].copy()
df_attacks_train["labels"] = df_train_to_attack["labels"].reset_index(drop=True)

# Clean the text
df_attacks_train["text"] = df_attacks_train["perturbed_text"].replace(
    "|", "", regex=True
)
df_attacks_train["text"] = df_attacks_train["text"].replace("", "n", regex=True)

# Prepare data to add to the training dataset
df_succ_attacks_train = df_attacks_train.loc[
    df_attacks_train.result_type == "Successful", ["text", "labels"]
]
df_succ_attacks_train.shape, df_succ_attacks_train.head(2)

Pelatihan permusuhan

Di bagian ini, kami menggabungkan serangan musuh yang berhasil dari data pelatihan dengan data pelatihan asli, lalu melatih model baru pada kumpulan data gabungan ini. Model ini disebut model terlatih permusuhan.

# New Train: Original Train + Successful Attacks on Original Train

df_train_attacked = pd.concat([df_train, df_succ_attacks_train], ignore_index=True)
data_train_attacked = Dataset.from_pandas(df_train_attacked)
data_train_attacked = data_train_attacked.map(
    preprocess_function, batched=True, load_from_cache_file=False, num_proc=num_proc
)

training_args_AT = TrainingArguments(
    output_dir=model_dir_AT,
    num_train_epochs=10,
    per_device_train_batch_size=32,
    per_device_eval_batch_size=64,
    warmup_steps=500,
    evaluation_strategy="epoch",
    save_strategy="epoch",
    save_total_limit=5,
    logging_dir=os.path.join(model_dir, "logs"),
    learning_rate=5e-6,
    load_best_model_at_end=True,
    metric_for_best_model="loss",
    disable_tqdm=True,
)

trainer_AT = Trainer(
    model=base_model,
    args=training_args_AT,
    train_dataset=data_train_attacked,
    eval_dataset=valid_dataset,
    compute_metrics=compute_metrics
)

trainer_AT.train()

Simpan model terlatih musuh ke direktori lokal model_dir_AT:

tokenizer.save_pretrained(model_dir_AT)
trainer_AT.save_model(model_dir_AT)

Mengevaluasi kekokohan model terlatih permusuhan

Sekarang model dilatih secara bermusuhan, kami ingin melihat bagaimana ketangguhan model berubah sesuai:

trained_model_AT = AutoModelForSequenceClassification.from_pretrained(model_dir_AT)
trained_model_AT = trained_model_AT.to("cuda:0")
trained_model_AT.device

model_wrapper_AT = CustomModelWrapper(trained_model_AT)
test_attack_results_AT = generate_attacks(recipe, model_wrapper_AT, test_dataset_to_attack, num_examples=-1)
df_attacks_AT_test, AT_test_exception_ids = log_attack_results(test_attack_results_AT)

ASR_AT_test = (
    df_attacks_AT_test.result_type.value_counts()["Successful"]
    / df_attacks_AT_test.result_type.value_counts().sum()
)

print(f"The Attack Success Rate of the model is {ASR_AT_test*100}%")

Kode sebelumnya mengembalikan hasil berikut:

The Attack Success Rate of the model is 19.8%

Bandingkan kekokohan model asli dan model terlatih musuh:

print(
    f"The ASR of the Adversarial Trained model has a {(ASR_test - ASR_AT_test)/ASR_test*100}% decrease compare with the original model. This proves that the Adversarial Training improves the model's robustness against the attacks."
)

Ini mengembalikan yang berikut:

The ASR of the Adversarial Trained model has a 62.213740458015266% decrease
compare with the original model. This proves that the Adversarial Training
improves the model's robustness against the attacks.

Sejauh ini, kami telah melatih pengklasifikasi bahasa toksisitas biner berbasis DistilBERT, menguji ketahanannya terhadap serangan teks permusuhan, melakukan pelatihan permusuhan untuk mendapatkan pengklasifikasi bahasa toksisitas baru, dan menguji ketahanan model baru terhadap serangan teks permusuhan.

Kami mengamati bahwa model yang dilatih musuh memiliki ASR yang lebih rendah, dengan penurunan 62.21% menggunakan ASR model asli sebagai tolok ukur. Hal ini menunjukkan bahwa model tersebut lebih kuat terhadap serangan musuh tertentu.

Evaluasi kinerja model

Selain kekokohan model, kami juga tertarik untuk mempelajari bagaimana model memprediksi sampel bersih setelah dilatih secara berlawanan. Dalam kode berikut, kami menggunakan mode prediksi batch untuk mempercepat proses evaluasi:

def batch_predict(model_wrapper, text_list, batch_size=64):
    """This function performs batch prediction for given model nad text list"""
    predictions = []
    for i in tqdm(range(0, len(text_list), batch_size)):
       batch = text_list[i : i + batch_size]
       model_predictions = model_wrapper(batch)[:, 1]
       model_predictions = model_predictions.cpu().numpy()
       predictions.append(model_predictions)
       predictions = np.concatenate(predictions, axis=0)
    return predictions

Evaluasi model aslinya

Kami menggunakan kode berikut untuk mengevaluasi model asli:

test_text_list = df_test.text.to_list()

model_predictions = batch_predict(model_wrapper, test_text_list, batch_size=64)

y_true_prob = np.array(df_test["labels"])
y_true = [0 if x < 0.5 else 1 for x in y_true_prob]

threshold = 0.5
y_pred_prob = model_predictions.flatten()
y_pred = [0 if x < threshold else 1 for x in y_pred_prob]

fig, ax = plt.subplots(figsize=(10, 10))
conf_matrix = confusion_matrix(y_true, y_pred)
ConfusionMatrixDisplay(conf_matrix).plot(ax=ax)
print(classification_report(y_true, y_pred))

Angka-angka berikut meringkas temuan kami.

Mengevaluasi model terlatih permusuhan

Gunakan kode berikut untuk mengevaluasi model terlatih permusuhan:

model_predictions_AT = batch_predict(model_wrapper_AT, test_text_list, batch_size=64)

y_pred_prob_AT = model_predictions_AT.flatten()
y_pred_AT = [0 if x < threshold else 1 for x in y_pred_prob_AT]

fig, ax = plt.subplots(figsize=(10, 10))
conf_matrix = confusion_matrix(y_true, y_pred_AT)
ConfusionMatrixDisplay(conf_matrix).plot(ax=ax)
print(classification_report(y_true, y_pred_AT))

Angka-angka berikut meringkas temuan kami.

Kami mengamati bahwa model terlatih permusuhan cenderung memprediksi lebih banyak contoh sebagai beracun (801 diprediksi sebagai 1) dibandingkan dengan model asli (763 diprediksi sebagai 1), yang mengarah pada peningkatan dalam mengingat kelas beracun dan ketepatan kelas tidak beracun. kelas, dan penurunan presisi kelas beracun dan penarikan kembali kelas tidak beracun. Ini mungkin karena fakta bahwa lebih banyak kelas beracun terlihat dalam proses pelatihan permusuhan.

Kesimpulan

Sebagai bagian dari moderasi konten, pengklasifikasi bahasa toksisitas digunakan untuk memfilter konten beracun dan menciptakan lingkungan online yang lebih sehat. Penyebaran model penyaringan toksisitas di dunia nyata tidak hanya membutuhkan kinerja prediksi yang tinggi, tetapi juga kuat terhadap rekayasa sosial, seperti serangan musuh. Posting ini memberikan proses langkah demi langkah dari melatih pengklasifikasi bahasa toksisitas hingga meningkatkan ketahanannya dengan pelatihan permusuhan. Kami menunjukkan bahwa pelatihan permusuhan dapat membantu model menjadi lebih kuat terhadap serangan sekaligus mempertahankan kinerja model yang tinggi. Untuk informasi lebih lanjut tentang topik yang akan datang ini, kami mendorong Anda untuk menjelajahi dan menguji skrip kami sendiri. Anda dapat mengakses buku catatan di pos ini dari Contoh AWS GitHub repo.

Hugging Face dan AWS mengumumkan kemitraan di awal tahun 2022 yang semakin memudahkan untuk melatih model Hugging Face di SageMaker. Fungsionalitas ini tersedia melalui pengembangan Memeluk Wajah AWS DLC. Wadah ini mencakup Pustaka Hugging Face Transformers, Tokenizers, dan Datasets, yang memungkinkan kami menggunakan sumber daya ini untuk pelatihan dan pekerjaan inferensi. Untuk daftar gambar DLC yang tersedia, lihat Tersedia Gambar Deep Learning Containers. Mereka dipelihara dan diperbarui secara teratur dengan tambalan keamanan.

Anda dapat menemukan banyak contoh cara melatih model Hugging Face dengan DLC berikut ini GitHub repo.

AWS menawarkan layanan AI AWS terlatih yang dapat diintegrasikan ke dalam aplikasi menggunakan panggilan API dan tidak memerlukan pengalaman ML. Sebagai contoh, Amazon Comprehend dapat melakukan tugas NLP seperti pengenalan entitas kustom, analisis sentimen, ekstraksi frasa kunci, pemodelan topik, dan lainnya untuk mengumpulkan wawasan dari teks. Itu dapat melakukan analisis teks pada berbagai bahasa untuk berbagai fiturnya.

Referensi

Tentang Penulis

Yi Xiang adalah Data Scientist II di Amazon Machine Learning Solutions Lab, tempat dia membantu pelanggan AWS di berbagai industri mempercepat adopsi AI dan cloud mereka.

Yanjunqi adalah Ilmuwan Terapan Utama di Lab Solusi Pembelajaran Mesin Amazon. Dia berinovasi dan menerapkan pembelajaran mesin untuk membantu pelanggan AWS mempercepat penerapan AI dan cloud mereka.