!python -c "import nltk; nltk.download('punkt')"

LexRank-Teil (Implementierung mit sumy)

def sectionLex():
  #Sprache auf Englisch eingestellt
  LANG = "english"
  #.txt-Datei(Körperdaten für jeden Abschnitt)Wählen Sie Alle
  file = glob.glob('*.txt')
  ex = []
  for i in range(len(file)):
    parser = PlaintextParser.from_file(file[i], Tokenizer(LANG))
    stemmer = Stemmer(LANG)
    summarizer = Summarizer(stemmer)
    summarizer.stop_words = get_stop_words(LANG)
    for sentence in summarizer(parser.document, [Wie viele Sätze ausgegeben werden sollen]):
      ex.append(str(sentence) + '\n')
    # utf-Ausgabe mit 8 Codierungen
    with open('output.txt', mode='w', encoding='utf-8') as f:
      f.writelines(ex)

Deklaration der im Wörterbuch verwendeten Variablen

#Regelmäßige Wörterbuchliste
chr_index = {}
#Wörterbuchliste umkehren
rvs_index = {}
#Liste der Aussagen
sentences = []
#Nächstes Wort
next_word = []

Teilen

# utf-Mit 8 Codierungen lesen und im Text speichern
with io.open('output.txt', encoding='utf-8') as f:
    text = f.read().lower()

#Wort für Wort aufschlüsseln (getrenntes Schreiben)
text = nltk.word_tokenize(text)
chars = text

Wörterbuch erstellen

#Erstellen Sie eine Liste in der richtigen Reihenfolge
count = 0
for c in chars:
    if not c in chr_index:
        chr_index[c] = count
        count += 1
        print(count, c)
#Erstellen Sie eine Liste in umgekehrter Reihenfolge
rvs_index = dict([(value, key) for (key, value) in chr_index.items()])

Teilzeichenfolgen erstellen

for i in range(0, len(text) - maxlen, step):
    #Teilzeichenfolge von Maxlenwörtern(1 Satz)Gespeichert als
    sentences.append(text[i: i + maxlen])
    #Speichert das nächste Wort der gespeicherten Teilzeichenfolge
    next_word.append(text[i + maxlen])

Wortvektorisierung

#np.3D-Array vom Typ Bool:(Anzahl der Teilzeichenfolgen, maximale Länge der Teilzeichenfolgen, Anzahl der Wörter)
x = np.zeros((len(sentences), maxlen, len(chars)), dtype=np.bool)
#np.Zweidimensionales Array vom Typ Bool:(Anzahl der Teilzeichenfolgen, Anzahl der Wörter)
y = np.zeros((len(sentences), len(chars)), dtype=np.bool)
#Vektorisieren Sie jeden Teilstring
for i, sentence in enumerate(sentences):
    for t, ch in enumerate(sentence):
        x[i, t, chr_index[ch]] = 1
    y[i, chr_index[next_word[i]]] = 1

Modell erstellen

Dieses Mal verwende ich das sequentielle Modell. In Bezug auf softmax war der [Artikel] von @ rtok (https://qiita.com/rtok/items/b1affc619d826eea61fd) leicht zu verstehen.

#Machen Sie ein einfaches Modell
model = Sequential()
#Verwendet LSTM. Die Stapelgröße beträgt 128
model.add(LSTM(128, input_shape=(maxlen, len(chars))))
#Machen Sie es möglich, die Wahrscheinlichkeit mit softmax für jedes Wort zu berechnen
model.add(Dense(len(chars), activation='softmax'))

Ich habe RMSprop für Gradientenmethode verwendet. Für RMSprop war der [Artikel] von @ tokkuman (https://qiita.com/tokkuman/items/1944c00415d129ca0ee9#rmsprop) leicht zu verstehen.

optimizer = RMSprop(learning_rate=0.01)
model.compile(loss='categorical_crossentropy', optimizer=optimizer)

Berechnen Sie die Erscheinungsrate jedes Wortes und wählen Sie das auszugebende Wort aus

#preds: Ausgabe aus dem Modell. Typ float32.
#Temperatur: Sorte. Je niedriger der Wert, desto einfacher ist es, den Wert mit der höheren Erscheinungsrate auszuwählen.
#Die Ausgabe des Modells erfolgt in Form einer Polynomverteilung, sodass die Summe 1 beträgt.Werden Sie 0
def selectWD(preds, temperature=1.0):
    #In den Typ float64 konvertieren
    preds = np.asarray(preds).astype('float64')
    #Teilen Sie den natürlichen Logarithmus durch die Sorte, um die Auswahl von Wörtern mit geringer Wahrscheinlichkeit zu erleichtern
    preds = np.log(preds) / temperature
    #Transformiere den natürlichen Logarithmus der Wahrscheinlichkeit umgekehrt (mache ihn zu einer natürlichen Exponentialfunktion)
    exp_preds = np.exp(preds)
    #Teilen Sie alle Werte durch die Summe, so dass die Summe 1 ist
    preds = exp_preds / np.sum(exp_preds)
    #Zufällig ausgewählt nach Polynomverteilung
    probas = np.random.multinomial(1, preds, 1)
    return np.argmax(probas)

Verarbeitung für jede Epoche

def on_epoch_end(epoch, _):
    print()
    print('----- Generating text after Epoch: %d' % epoch)
    #Setzen Sie die ersten 4 Wörter an den Anfang der Eingabezeichenfolge
    start_index = 0
    #Vielfalt: Vielfalt. Entspricht der SelectWD-Temperatur. Zeichen mit einer geringeren Wahrscheinlichkeit werden ebenfalls ausgewählt, da sie höher sind.
    for diversity in [0.2, 0.5, 0.8, 1.0]:
        print('----- diversity:', diversity)
        #Zur Ausgabe
        generated = ''
        sentence = text[start_index: start_index + maxlen]
        generated += " ".join(sentence)
        print(" ".join(sentence))

        print('----- Generating with seed: "' + " ".join(sentence)+ '"')
        sys.stdout.write(generated)
        
        #Geben Sie AUSSEN Sätze aus oder beenden Sie mit 1000 Wörtern
        flag = OUTSEN
        for i in range(1000):
            #Welches Wort steht an welcher Stelle im aktuellen Satz?
            x_pred = np.zeros((1, maxlen, len(chars)))
            for t, ch in enumerate(sentence):
                x_pred[0, t, chr_index[ch]] = 1.
            #Sagen Sie das nächste Wort voraus
            preds = model.predict(x_pred, verbose=0)[0]
            next_index = selectWD(preds, diversity)
            next_char = rvs_index[next_index]
            #Entfernen Sie das erste Wort und fügen Sie das vorhergesagte Wort danach hinzu
            sentence = sentence[1:]
            sentence.append(next_char)
            #Ausgabeorganisation
            if next_char == '.':
                flag -= 1
                generated += next_char + "\n"
                sys.stdout.write(next_char+"\n")
            elif next_char == ',':
                generated += next_char
                sys.stdout.write(next_char)
            else:
                generated += " " + next_char
                sys.stdout.write(" "+next_char)
            sys.stdout.flush()
            if flag <= 0:
                break
        sys.stdout.flush()
        print()

#Stellen Sie den obigen Prozess in jeder Epoche auf
print_callback = LambdaCallback(on_epoch_end=on_epoch_end)

Anpassungsprozess

#Die Stapelgröße 128, Epochennummer 100, ruft die zuvor beschriebene Funktion auf
model.fit(x, y, batch_size=128, epochs=100, callbacks=[print_callback])

Ergebnis

Dies ist das Ergebnis der Verwendung von Botta et al. Integration von Cloud Computing und Internet der Dinge: Eine Umfrage (2016) als Daten.

----- Generating text after Epoch: 99 ----- diversity: 0.2 in general , iot ----- Generating with seed: "in general , iot" in general , iot can benefit from the virtually unlimited capabilities and resources of cloud to compensate its technological constraints ( e.g., storage, processing, communication ). being iot characterized by a very high heterogeneity of devices, technologies, and protocols, it lacks different important properties such as scalability, interoperability, flexibility, reliability, efficiency, availability, and security. as a consequence, analyses of unprecedented complexity are possible, and data-driven decision making and prediction algorithms can be employed at low cost, providing means for increasing revenues and reduced risks. the availability of high speed networks enables effective monitoring and control of remote things, their coordination, their communications, and real-time access to the produced data. this represents another important cloudiot driver : iot processing needs can be properly satisfied for performing real-time data analysis ( on-the-fly ), for implementing scalable, real-time, collaborative, sensor-centric applications, for managing complex events, and for supporting task offloading for energy saving.

Ich gebe 5 Sätze aus, aber wenn ich es mit Google-Übersetzung ins Japanische übersetze, sieht es so aus.

Im Allgemeinen kann iot von praktisch unbegrenzten Funktionen und Ressourcen in der Cloud profitieren, um technische Einschränkungen (Speicherung, Verarbeitung, Kommunikation usw.) auszugleichen. Es weist ein sehr hohes Maß an Heterogenität bei Geräten, Technologien und Protokollen auf und verfügt nicht über verschiedene wichtige Eigenschaften wie Skalierbarkeit, Interoperabilität, Flexibilität, Zuverlässigkeit, Effizienz, Verfügbarkeit und Sicherheit. Das Ergebnis ist eine beispiellose Komplexitätsanalyse und die kostengünstige Einführung datengesteuerter Entscheidungs- und Vorhersagealgorithmen, um den Umsatz zu steigern und das Risiko zu verringern. Die Hochgeschwindigkeitsnetzwerkverfügbarkeit ermöglicht eine effektive Überwachung und Steuerung von Remote-Objekten, deren Koordination, Kommunikation und Echtzeitzugriff auf generierte Daten. Dies ist ein weiterer wichtiger Cloudiot-Treiber: Durchführung einer Echtzeit-Datenanalyse (on-the-fly), Implementierung skalierbarer, auf die Zusammenarbeit ausgerichteter sensorzentrierter Anwendungen in Echtzeit, Verwaltung komplexer Ereignisse und Auslagerung von Aufgaben, um Geld zu sparen. Unterstützt.

Es fühlt sich wie organisiert an!

Der gesamte Quellcode ist auf [github] verfügbar (https://github.com/7vvXi/writeEnglish). Es gibt einige seltsame Dinge auf Japanisch, also werde ich es verbessern ...