[PYTHON] [Erklärung zur Implementierung] Klassifizieren Sie Livedoor-Nachrichten nach japanischem BERT x unbeaufsichtigtem Lernen (Clustering zur Maximierung der Informationsmenge): Google Colaboratory (PyTorch)
In diesem Artikel werden wir implementieren und erläutern, wie das Clustering der unbeabsichtigten Lernmaximierung für die Nachrichtenmenge mithilfe der japanischen Version von BERT in Google Colaboratory für lebende Nachrichten durchgeführt wird.
--Inhalte bis zur Vektorisierung von Sätzen mit der japanischen Version von BERT in Google Colaboratory,
- Clustering der Informationsmengenmaximierung für unbeaufsichtigtes Lernen in MNIST
Ich habe dies in den bisher serialisierten Artikeln erklärt. Bitte schauen Sie zuerst hier.
** Serienliste ** [1] [Erklärung zur Implementierung] Verwendung der japanischen Version von BERT in Google Colaboratory (PyTorch) [2] [Erklärung zur Implementierung] Livedoor-Nachrichtenklassifizierung in der japanischen Version BERT: Google Colaboratory (PyTorch) [3] [Erklärung zur Implementierung] Gehirnforschung und unbeaufsichtigtes Lernen. Klassifizieren Sie MNIST nach Clustering zur Maximierung der Informationsmenge [4] * Dieser Artikel [Erklärung zur Implementierung] Klassifizieren von Livedoor-Nachrichten nach japanischem BERT x unbeaufsichtigtem Lernen (Clustering zur Maximierung der Informationsmenge)
Letztes Mal habe ich einen Artikel über MNISTs handgeschriebenes numerisches Bild geschrieben. Invariant Information Clustering for Unsupervised Image Classification and Segmentation
Clustering von unbeaufsichtigtem Lernen unter Verwendung gegenseitiger Informationen IIC（Invariant Information Clustering） Wurde rausgebracht.
Dieses Mal werden wir zeigen, was passiert, wenn jeder Nachrichtenartikel von Livedoor-Nachrichten mit japanischem BERT vektorisiert und ohne Aufsicht (Clustering) mit IIC gelernt wird.
Im Fall von MNIST wird das Clustering-Ergebnis nach der numerischen Bezeichnung des überwachten Lernens aufgeteilt, und es fühlt sich gut an, dass es für überwachtes Lernen verwendet werden kann, aber was ist mit Textdaten?
Ich werde es versuchen.
Der Ablauf dieser Implementierung ist
- Laden Sie Livedoor-Nachrichten herunter und konvertieren Sie sie in den DataLoader von PyTorch
- Vektorisieren Sie lebende Nachrichtenartikel mit BERT
- IIC Deep Learning-Modell verfügbar
- Lernen Sie das IIC-Netzwerk kennen
- Testdaten ableiten
Es wird sein.
Der Implementierungscode für diesen Beitrag befindet sich im GitHub-Repository unten.
GitHub: Verwendung der japanischen Version von BERT in Google Colaboratory: Implementierungscode Es ist 4_BERT_livedoor_news_IIC_on_Google_Colaboratory.ipynb.
1. Laden Sie Livedoor-Nachrichten herunter und konvertieren Sie sie in den DataLoader von PyTorch
Der Inhalt ist bisher [[2] [Erklärung zur Implementierung] Livedoor-Nachrichtenklassifizierung in der japanischen Version BERT: Google Colaboratory (PyTorch)](https: //)
So wie es ist, werde ich die Veröffentlichung in diesem Artikel weglassen.
Erstellen Sie abschließend einen Trainings-, Validierungs- und Test-DataLoader, indem Sie folgende Schritte ausführen:
#Erstellen Sie einen DataLoader (im Kontext von torchtext einfach als Iterater bezeichnet).
batch_size = 16 #BERT verwendet ungefähr 16 und 32
dl_train = torchtext.data.Iterator(
dataset_train, batch_size=batch_size, train=True)
dl_eval = torchtext.data.Iterator(
dataset_eval, batch_size=batch_size, train=False, sort=False)
dl_test = torchtext.data.Iterator(
dataset_test, batch_size=batch_size, train=False, sort=False)
#In einem Wörterbuchobjekt zusammenfügen
dataloaders_dict = {"train": dl_train, "val": dl_eval}
Vectorize Livedoor-Nachrichtenartikel mit BERT
Vektorisieren Sie den Artikelkörper der Livedoor-Nachrichten mit der japanischen Version von BERT.
Es wird eine Vektorisierung des Dokuments sein.
Dieses Mal werde ich einfach den 768-dimensionalen eingebetteten Vektor des ersten Wortes von BERT ([CLS]) als Dokumentvektor behandeln (es gibt verschiedene Möglichkeiten, einen Dokumentvektor und seine Gültigkeit zu erstellen).
Da es Zeitverschwendung ist, Dokumentdaten jedes Mal zu vektorisieren, wenn ein neuronales Netzwerk für das Clustering durch IIC trainiert wird, erstellen Sie einen DataLoader, der von BERT in einen Dokumentvektor konvertiert wurde.
Die Implementierung ist wie folgt:
Bereiten Sie zunächst den Hauptteil von BERT vor. Es ist eine Parameterversion der Tohoku-Universität, die bereits Japanisch gelernt hat.
from transformers.modeling_bert import BertModel
#BERTs japanisch erlerntes Parametermodell
model = BertModel.from_pretrained('bert-base-japanese-whole-word-masking')
model.eval()
print('Netzwerkeinstellung abgeschlossen')
Definieren Sie als Nächstes eine Funktion zum Vektorisieren mit BERT.
#Definieren Sie eine Funktion zum Vektorisieren mit BERT
def vectorize_with_bert(net, dataloader):
#Überprüfen Sie, ob eine GPU verwendet werden kann
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print("Verwendetes Gerät:", device)
print('-----start-------')
#Netzwerk zur GPU
net.to(device)
#Wenn das Netzwerk bis zu einem gewissen Grad repariert ist, beschleunigen Sie
torch.backends.cudnn.benchmark = True
#Mini-Chargengröße
batch_size = dataloader.batch_size
#Schleife zum Abrufen des Mini-Batch vom Datenlader
for index, batch in enumerate(dataloader):
#Batch ist ein Text- und Lable-Wörterbuchobjekt
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
inputs = batch.Text[0].to(device) #Satz
labels = batch.Label.to(device) #Etikette
#Vorwärtsberechnung
with torch.set_grad_enabled(False):
#Geben Sie in Ber
result = net(inputs)
# sequence_Extrahieren Sie den ersten Wortvektor der Ausgabe
vec_0 = result[0] #Die erste 0 ist die Sequenz_Ausgabe anzeigen
vec_0 = vec_0[:, 0, :] #Alle Chargen. Alle 768 Elemente des ersten 0. Wortes
vec_0 = vec_0.view(-1, 768) #Größe[batch_size, hidden_size]Umstellung auf
#Organisieren Sie vektorisierte Daten in einer Taschenlampenliste
if index == 0:
list_text = vec_0
list_label = labels
else:
list_text = torch.cat([list_text, vec_0], dim=0)
list_label = torch.cat([list_label, labels], dim=0)
return list_text, list_label
Vektorisieren Sie die Trainings-, Validierungs- und Test-DataLoader mit den definierten Funktionen.
#Konvertieren Sie DataLoader in eine vektorisierte Version
#Es dauert etwas weniger als 5 Minuten
list_text_train, list_label_train = vectorize_with_bert(model, dl_train)
list_text_eval, list_label_eval = vectorize_with_bert(model, dl_eval)
list_text_test, list_label_test = vectorize_with_bert(model, dl_test)
Machen Sie diese Liste dann zu einem PyToch-Datensatz.
#Fackelliste in Datensatz konvertieren
from torch.utils.data import TensorDataset
dataset_bert_train = TensorDataset(
list_label_train.view(-1, 1), list_text_train)
dataset_bert_eval = TensorDataset(list_label_eval.view(-1, 1), list_text_eval)
dataset_bert_test = TensorDataset(list_label_test.view(-1, 1), list_text_test)
Stellen Sie den Datensatz schließlich auf DataLoader ein. Dieser DataLoader wird für das Lernen im IIC-Netzwerk (Invariant Information Clustering) verwendet.
#Machen Sie es zu einem Dataloader
from torch.utils.data import DataLoader
batch_size = 1024
dl_bert_train = DataLoader(
dataset_bert_train, batch_size=batch_size, shuffle=True, drop_last=True)
# drop_last ist die letzte Mini-Batch-Charge_Ignorieren, wenn die Größe nicht ausreicht
dl_bert_eval = DataLoader(
dataset_bert_eval, batch_size=batch_size, shuffle=False)
dl_bert_test = DataLoader(
dataset_bert_test, batch_size=batch_size, shuffle=False)
Mit dem oben Gesagten wurde der Text von Livedoor News in japanischem BERT vektorisiert.
Jetzt müssen Sie nur noch diese vektorisierten Daten gruppieren.
Vorbereitung 3: Bereiten Sie das IIC-Deep-Learning-Modell vor
Bereiten Sie als Nächstes ein Deep-Learning-Modell für IIC vor. Dieser Teil ist im Grunde
Erklärung zur Implementierung Gehirnforschung und unbeaufsichtigtes Lernen. Klassifizieren Sie MNIST nach Clustering zur Maximierung der Informationsmenge](https://qiita.com/sugulu/items/e3c01a0776a5df3ad552)
Es hat die gleiche Konfiguration wie.
Das neuronale Netzwerkmodell sollte einem 768-dimensionalen Vektor entsprechen. Dieses Mal wird der Merkmalsbetrag durch Wiederholen des Faltens von 1d umgewandelt.
Gleichzeitig wird auch das 10-fache der durch Überclustering geschätzten Clustering-Anzahl von Clustern durchgeführt, und das Netzwerk, das kleinste Funktionen erfasst, wird trainiert.
import torch.nn as nn
import torch.nn.functional as F
OVER_CLUSTRING_RATE = 10
class NetIIC(nn.Module):
def __init__(self):
super(NetIIC, self).__init__()
# multi-Kopf macht diesmal nicht
self.conv1 = nn.Conv1d(1, 400, kernel_size=768, stride=1, padding=0)
self.bn1 = nn.BatchNorm1d(400)
self.conv2 = nn.Conv1d(1, 300, kernel_size=400, stride=1, padding=0)
self.bn2 = nn.BatchNorm1d(300)
self.conv3 = nn.Conv1d(1, 300, kernel_size=300, stride=1, padding=0)
self.bn3 = nn.BatchNorm1d(300)
self.fc1 = nn.Linear(300, 250)
self.bnfc1 = nn.BatchNorm1d(250)
#Entspricht es 9 Kategorien von Livedoor-Nachrichten? 9 Kategorien zu erwarten
self.fc2 = nn.Linear(250, 9)
# overclustering
#Wenn Sie mehr als die tatsächliche Annahme gruppieren, können Sie kleinste Änderungen im Netzwerk erfassen.
self.fc2_overclustering = nn.Linear(250, 9*OVER_CLUSTRING_RATE)
def forward(self, x):
x = x.view(x.size(0), 1, -1)
x = F.relu(self.bn1(self.conv1(x)))
x = x.view(x.size(0), 1, -1)
x = F.relu(self.bn2(self.conv2(x)))
x = x.view(x.size(0), 1, -1)
x = F.relu(self.bn3(self.conv3(x)))
x = x.view(x.size(0), -1)
x_prefinal = F.relu(self.bnfc1(self.fc1(x)))
# multi-Verwenden Sie keinen Kopf
y = F.softmax(self.fc2(x_prefinal), dim=1)
y_overclustering = F.softmax(self.fc2_overclustering(
x_prefinal), dim=1) # overclustering
return y, y_overclustering
Definiert eine Initialisierungsfunktion für Modellgewichtsparameter.
import torch.nn.init as init
def weight_init(m):
"""Gewichtsinitialisierung"""
if isinstance(m, nn.Conv1d):
init.normal_(m.weight.data)
if m.bias is not None:
init.normal_(m.bias.data)
elif isinstance(m, nn.BatchNorm1d):
init.normal_(m.weight.data, mean=1, std=0.02)
init.constant_(m.bias.data, 0)
elif isinstance(m, nn.Linear):
# Xavier
# init.xavier_normal_(m.weight.data)
# He
init.kaiming_normal_(m.weight.data)
if m.bias is not None:
init.normal_(m.bias.data)
Definiert, wie die Verlustfunktion für IID berechnet wird.
Berechnen Sie die Menge an gegenseitigen Informationen zwischen der Ausgabe (x_out), wenn die vektorisierten Zieldaten in NetIID eingegeben werden, und der Ausgabe (x_tf_out), wenn die konvertierten Daten der vektorisierten Zieldaten in NetIID eingegeben werden.
Weitere Informationen zur Implementierung finden Sie im vorherigen Artikel.
Erklärung zur Implementierung Gehirnforschung und unbeaufsichtigtes Lernen. Klassifizieren Sie MNIST nach Clustering zur Maximierung der Informationsmenge](https://qiita.com/sugulu/items/e3c01a0776a5df3ad552)
#Definition der Verlustfunktion durch IIS
#Referenz: https://github.com/RuABraun/phone-clustering/blob/master/mnist_basic.py
import sys
def compute_joint(x_out, x_tf_out):
bn, k = x_out.size()
assert (x_tf_out.size(0) == bn and x_tf_out.size(1) == k), '{} {} {} {}'.format(
bn, k, x_tf_out.size(0), x_tf_out.size(1))
p_i_j = x_out.unsqueeze(2) * x_tf_out.unsqueeze(1) # bn, k, k
p_i_j = p_i_j.sum(dim=0) # k, k
p_i_j = (p_i_j + p_i_j.t()) / 2. # symmetrise
p_i_j = p_i_j / p_i_j.sum() # normalise
return p_i_j
def IID_loss(x_out, x_tf_out, EPS=sys.float_info.epsilon):
# has had softmax applied
bs, k = x_out.size()
p_i_j = compute_joint(x_out, x_tf_out)
assert (p_i_j.size() == (k, k))
p_i = p_i_j.sum(dim=1).view(k, 1).expand(k, k)
p_j = p_i_j.sum(dim=0).view(1, k).expand(k, k)
# avoid NaN losses. Effect will get cancelled out by p_i_j tiny anyway
#Dies ist Version 1 von PyTorch.Wenn es 3 oder mehr ist, tritt ein Fehler auf.
# https://discuss.pytorch.org/t/pytorch-1-3-showing-an-error-perhaps-for-loss-computed-from-paired-outputs/68790/3
#p_i_j[(p_i_j < EPS).data] = EPS
#p_j[(p_j < EPS).data] = EPS
#p_i[(p_i < EPS).data] = EPS
p_i_j = torch.where(p_i_j < EPS, torch.tensor(
[EPS], device=p_i_j.device), p_i_j)
p_j = torch.where(p_j < EPS, torch.tensor([EPS], device=p_j.device), p_j)
p_i = torch.where(p_i < EPS, torch.tensor([EPS], device=p_i.device), p_i)
# https://qiita.com/Amanokawa/items/0aa24bc396dd88fb7d2a
#Gewicht Alpha als Referenz hinzugefügt
alpha = 2.0
loss = (- p_i_j * (torch.log(p_i_j) - alpha *
torch.log(p_j) - alpha*torch.log(p_i))).sum()
return loss
Definieren Sie als Nächstes die Transformation, die auf die interessierenden vektorisierten Daten angewendet werden soll.
Diese Konvertierungsfunktion ist der Schlüssel zu IIC.
Im Fall von Bilddaten werden die affine Umwandlung (Drehung / Dehnung), die Änderung des Seitenverhältnisses, das Abschneiden (Abschneiden) und das Hinzufügen von Rauschen gemäß der normalen Datenerweiterung durchgeführt.
Was soll ich mit Textdaten machen ...
Bei der Datenerweiterung in Wettbewerben wie Kaggle übersetzen wir sie einmal in eine andere Sprache.
Dieses Mal werde ich einfach Rauschen basierend auf der Standardabweichung aller Vektordaten hinzufügen.
#Definition einer Funktion, die Daten Rauschen hinzufügt
device = 'cuda' if torch.cuda.is_available() else 'cpu'
tensor_std = list_text_train.std(dim=0).to(device)
def perturb_data(x):
y = x.clone()
noise = torch.randn(len(tensor_std)).to(device)*tensor_std*2.0
noise = noise.expand(x.shape[0], -1)
y += noise
return y
4: Lernen Sie das IIC-Netzwerk kennen
Nachdem die DataLoader- und IIC-Modelle fertig sind, trainieren wir die Gewichte des IIC-Modells.
Definieren Sie zunächst die Trainingsfunktion.
#Definition der Lernfunktion
def train(total_epoch, model, train_loader, optimizer, device):
#Versetzen Sie das Netzwerk in den Trainingsmodus
model.train()
#Lernratenplaner CosAnnealing
scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(
optimizer, T_0=2, T_mult=2, eta_min=0)
for epoch in range(total_epoch):
for batch_idx, (target, data) in enumerate(train_loader):
#Änderung der Lernrate
scheduler.step()
data_perturb = perturb_data(data) #Geben Sie Rauschen und erstellen Sie konvertierte Daten
#Senden, wenn an die GPU gesendet
data = data.to(device)
data_perturb = data_perturb.to(device)
#Initialisierung der Optimierungsfunktion
optimizer.zero_grad()
#Betreten Sie das neuronale Netzwerk
output, output_overclustering = model(data)
output_perturb, output_perturb_overclustering = model(data_perturb)
#Verlustberechnung
loss1 = IID_loss(output, output_perturb)
loss2 = IID_loss(output_overclustering,
output_perturb_overclustering)
loss = loss1 + loss2
#Aktualisiert, um Verluste zu reduzieren
loss.backward()
optimizer.step()
#Protokollausgabe
if epoch % 50 == 0:
print('Train Epoch {} \tLoss1: {:.6f} \tLoss2: {:.6f} \tLoss_total: {:.6f}'.format(
epoch, loss1.item(), loss2.item(), loss1.item()+loss2.item()))
return model, optimizer
In der obigen Schulung wird die Lernrate geändert, indem Cosine Annealing Warm Restarts des Schedulers vorbereitet werden.
Dies ist ein Gerät, das die Lernrate wie unten gezeigt ändert, um das Lernen der Parameter von der lokalen Lösung zur globalen Mindestlösung zu erleichtern, wenn der Wert plötzlich von einem kleinen Wert erhöht wird.
Abbildung: Zitat
https://www.kaggle.com/c/imet-2019-fgvc6/discussion/94783
Wir lernen. Dieses Mal beträgt die Stapelgröße 1.024 und die Daten selbst etwa 4.000, sodass wir die Anzahl der Epochen erhöhen.
Das Lernen dauert weniger als 5 Minuten.
#Implementierung des Lernens (weniger als 5 Minuten)
total_epoch = 1000
optimizer = torch.optim.Adam(net.parameters(), lr=5e-4) #Optimierungsfunktion
model_trained, optimizer = train(
total_epoch, net, dl_bert_train, optimizer, device)
Nachdem das Training abgeschlossen ist, lassen Sie uns mit den Testdaten schließen. Um das Verständnis der Ergebnisse zu erleichtern, bereiten Sie einen DataLoader zum Testen mit einer Mini-Batch-Größe 1 vor und schließen Sie nacheinander. Speichern Sie das Ergebnis.
Die Funktion ist unten definiert.
#Überprüfen Sie die Ergebnisse des Modellklassifizierungsclusters
import numpy as np
#Bereiten Sie den Data Loader für den Mini-Batch-Test der Größe 1 vor
dl_bert_test = DataLoader(
dataset_bert_test, batch_size=1, shuffle=False)
def test(model, device, test_loader):
model.eval()
out_targs = []
ref_targs = []
#Bereiten Sie eine Liste für die Ausgabe vor
total_num = len(test_loader)
# index, (target_label, inferenced_label)
output_list = np.zeros((total_num, 2))
with torch.no_grad():
for batch_idx, (target, data) in enumerate(test_loader):
data = data.to(device)
target = target.to(device)
outputs, outputs_overclustering = model(data)
#Klassifizierungsergebnis zur Liste hinzufügen
out_targs.append(outputs.argmax(dim=1).cpu())
ref_targs.append(target.cpu())
#Tragen Sie die Ergebnisse in eine Liste ein
output_list[batch_idx, 0] = target.cpu() #Richtiges Antwortetikett
output_list[batch_idx, 1] = outputs.argmax(dim=1).cpu() #Vorhersage-Label
out_targs = torch.cat(out_targs)
ref_targs = torch.cat(ref_targs)
return out_targs.view(-1, 1).numpy(), ref_targs.numpy(), output_list
5. Testdaten ableiten
Inferenz mit Testdaten durchführen.
#Inferenz mit Testdaten durchführen
out_targs, ref_targs, output_list = test(model_trained, device, dl_bert_test)
Überprüfen Sie die Häufigkeitstabelle der Verwirrungsmatrix der Inferenzergebnisse in den Testdaten.
#Machen Sie eine Verwirrungsmatrix
matrix = np.zeros((9, 9))
#Erstellen Sie eine korrekte Antwortklasse für lebende Nachrichten vertikal und eine Häufigkeitstabelle für die horizontal beurteilten Klassen
for i in range(len(out_targs)):
row = ref_targs[i]
col = out_targs[i]
matrix[row][col] += 1
np.set_printoptions(suppress=True)
print(matrix)
Das Ausgabeergebnis ist wie folgt.
[[ 55. 0. 1. 0. 4. 47. 2. 76. 0.]
[ 3. 40. 4. 0. 14. 1. 1. 0. 116.]
[ 7. 39. 21. 4. 16. 3. 6. 3. 1.]
[ 11. 60. 16. 4. 13. 8. 27. 2. 17.]
[ 8. 6. 20. 107. 1. 8. 16. 0. 1.]
[ 11. 17. 15. 0. 40. 6. 78. 7. 0.]
[ 18. 3. 65. 40. 13. 15. 14. 3. 1.]
[ 63. 7. 45. 11. 2. 42. 7. 1. 1.]
[ 27. 0. 6. 0. 4. 61. 1. 61. 1.]]
Außerdem hat die vertikale Achse die folgende Reihenfolge, nachdem der Inhalt von "dic_id2cat" überprüft wurde.
{0: 'sports-watch',
1: 'dokujo-tsushin',
2: 'livedoor-homme',
3: 'peachy',
4: 'smax',
5: 'movie-enter',
6: 'it-life-hack',
7: 'kaden-channel',
8: 'topic-news'}
Erstens stimmen die Cluster, von denen angenommen wurde, dass sie Klassen sind, wie in MNIST, nicht genau überein. Ich denke das ist so etwas.
Wenn Sie angewiesen werden, "eine große Anzahl von Dokumenten in mehrere Typen zu klassifizieren", denke ich, dass sogar Menschen in verschiedenen Mustern klassifizieren (Cluster). Als ich gebeten wurde, Livedoor-Nachrichten in 9 Kategorien einzuteilen, erhielt ich dieses Ergebnis.
Der zweite geschätzte Cluster ist meistens "it-life-hack" und "kaden-channel". Der dritte der geschätzten Cluster ist "smax (Smartphones und Gadgets)". Der letzte abgeleitete Cluster scheint ein Cluster mit viel "Einzelkommunikation" zu sein.
Das vorletzte ist meistens "Sportuhr" und "Themennachrichten". Die Klassen "Sportuhr" und "Themen-Nachrichten" befinden sich im geschätzten Cluster Es ist in 0, 5 und 7 unterteilt.
- Clustertext, 7. Clustertext der "Sportuhr" Der Text des 5. Clusters und der Text des 7. Clusters in "Topic-News"
Werfen wir einen Blick auf die Funktionen von Cluster 5 und Cluster 7.
#Überprüfen Sie das Ergebnis des Clusters
#「sports-5. Clustertext von "watch", 7. Clustertext
#「topic-5. Clustertext von "Nachrichten", 7. Clustertext
#Werfen wir einen Blick auf die Funktionen von Cluster 5 und Cluster 7.
import pandas as pd
df2 = pd.DataFrame(output_list)
df2.columns=["Richtige Antwortklasse", "Geschätzter Cluster"]
df2.head()
df2[(df2['Richtige Antwortklasse']==0) & (df2['Geschätzter Cluster']==5)].head()
Die Ausgabe ist wie folgt.
Richtige Klasse Geschätzter Cluster
21 0.0 5.0
59 0.0 5.0
126 0.0 5.0
142 0.0 5.0
153 0.0 5.0
Werfen wir einen Blick auf den 21. und 59. Satz des Testdatensatzes.
#Das Originaldokument wird in df abgelegt. Schauen Sie sich ungefähr 300 Zeichen an.
print(df.iloc[21, 0][:300])
print(df.iloc[59, 0][:300])
Der erste Satz der fünften Gruppe von "Sportuhren" lautet
Am 29. des letzten Monats, nachdem Kotetsu Yamamoto als professioneller Wrestler in den Ruhestand getreten war, der von den Fans als Spielertraining, Kommentator und Schiedsrichter geliebt wurde, starb er plötzlich an einer hypoxischen Enzephalopathie und betrübte die Fans und verwandte Parteien zutiefst. Zu dieser Zeit berichtete "Weekly Asahi Performing Arts", das am 7. dieser Woche veröffentlicht wurde, über eine erstaunliche Aktion in der "NEWS SHOT!" - Ecke, die Mr. Yamamotos Heldentum "unmittelbar vor seinem Tod" zeigt. Der frühere wöchentliche professionelle Wrestling-Redakteur Tarzan Yamamoto, der das Magazin kommentierte, sagte: "Der Körper, 170 cm groß und 113 kg schwer, hält immer noch Muskeln aufrecht, die an die aktive Ära erinnern. Er ist so hart wie junge Leute. Nach dem Training hatte ich mit 68 Jahren einen unglaublichen Appetit, aber tatsächlich war Herr Yamamoto Diabetiker ", sagte er.
ist geworden.
Ähnlich,
Der erste Satz des 7. Clusters der "Sportuhr" lautet
Interview mit dem ehemaligen Regisseur Hiromitsu Ochiai von den Chunichi Dragons, in dem schockierende Worte wie "Alles wurde verrückt", "Ich habe den Krug nie berührt" und "Niemand vertraut mir" nacheinander auftauchten. .. Im Nippon-Fernsehen "Going! Sports & News" war der Baseball-Kommentator Taku Egawa der Zuhörer, und das Muster wurde zwei Nächte lang (17. und 18.) ausgestrahlt. In der ersten Sendung enthüllte Herr Ochiai eine unbekannte Episode und sagte: "Wenn ich nächstes Jahr eine Uniform trage, werde ich nicht so weit reden", aber der zweite Teil der Sendung ist noch überraschender. Es wurde der Inhalt, der sein sollte. Unten finden Sie eine Zusammenfassung des Interviews. Egawa: Hast du gedacht, du könntest dieses Jahr der Beste in Japan sein? Ich habe nicht gedacht
ist. Der erste Satz des fünften Clusters von "Topic-News" lautet
In Südkorea ist es eine allgemeine Regel, dass Mönche ledig sind, aber das Facebook des Mönchs, auf dem steht: "Ich war verzweifelt und habe beschlossen, das Haus zu verlassen, ohne vom anderen Geschlecht beliebt zu sein", ist zu einem heißen Thema im koreanischen Online-Bulletin Board geworden. Der Mönch namens Hyobon sagte am 19. auf Facebook: "Ich war in meinen Zwanzigern beim anderen Geschlecht nicht beliebt. Ich kam zu dem Schluss, dass ich nichts dagegen tun konnte, und beschloss, das Haus zu verlassen. Alle gaben auf." Geh aus dem Haus. Wenn ich jetzt darüber nachdenke, hätte ich in jungen Jahren Runden und Punks machen sollen ", sagte er. In Bezug auf das Leben eines Priesters sagte er: "Je früher Sie das Haus verlassen, desto schneller werden Sie großartig. Wenn Sie großartig werden, müssen Sie sich keine Sorgen um Reis und Waschen machen."
ist. Der erste Satz des 7. Clusters von "Topic-News" lautet
Am 18. berichtete der Nihon Keizai Shimbun über die verzerrte Realität des Katastrophengebiets in einem Artikel mit dem Titel "Eine weitere ungewöhnliche Situation in dem betroffenen Gebiet: Besondere Forderung nach Wiederaufbau / Entschädigung für Kernkraftwerke ... Geldzufluss verzerrte Regeneration". ing. In demselben Artikel wies er darauf hin, dass, wenn die zu entschädigende Familie eine fünfköpfige Familie ist, 800.000 Yen pro Monat in der Tasche stecken: "Ich habe Geld von TEPCO bekommen, und selbst wenn ich nicht arbeite, kann ich pachinko, Sushi essen und ein neues Smartphone und eine neue Tasche haben. Die Worte der Einheimischen "Ich mache es" werden veröffentlicht. Die Entschädigung, die den Opfern zufließt und wie sie verwendet werden, wird als "verzerrte Regeneration" positioniert. Am Online-Schwarzen Brett: "Ich habe kein Geld gesammelt, ich hatte keinen blinden Fleck", "Sama-sama", "Es macht mir nichts aus, weil Smartphones und Sushi konsumiert werden, aber Pachinko ist nicht gut."
ist.
Sie können die Eigenschaften nicht wirklich verstehen, wenn Sie nur den Text betrachten. .. ..
Sie können jedoch sehen, dass Sport und Nachrichten eine sehr ähnliche Artikelatmosphäre haben.
Mehr als das, um eine bessere Vorstellung von den Eigenschaften von IIC-Clustern zu bekommen
- Sehen Sie sich den Trend der Worthäufigkeit mit Wordcloud an
- Schwächen Sie alle Vektoren des Clusterdokuments, um einen Clustervektor zu erstellen, entscheiden Sie das repräsentative Dokument und geben Sie ähnliche Wörter aus
Solche Operationen können in Betracht gezogen werden.
Es ist zu lang, um das in diesem Artikel zu tun, also ist es das für diese Zeit.
Der Implementierungscode für diesen Beitrag befindet sich im GitHub-Repository unten.
GitHub: Verwendung der japanischen Version von BERT in Google Colaboratory: Implementierungscode Es ist 4_BERT_livedoor_news_IIC_on_Google_Colaboratory.ipynb.
Das Obige ist ein Implementierungsbeispiel und eine Erklärung für Live-Nachrichten als IIC-Clustering für unbeaufsichtigtes Lernen in japanischem BERT.
Danke fürs Lesen.
[Haftungsausschluss] Der Inhalt dieses Artikels selbst ist die Meinung / Übermittlung des Autors, nicht die offizielle Meinung des Unternehmens, zu dem der Autor gehört.
Recommended Posts