JavaScript ( ES7), 39/50 (78%)

63,5% (127/200) bei versteckten Testfällen

Eine einfache Heuristik basierend auf der Länge des Titels, der Anzahl der Leerzeichen und Verwendung des Suffixes -ly.

 isOnion = str => str.length ** 0.25 + str.split(" ").length ** 1.25 * 2 + str.split(/ly\b/).length ** 1.75 * 7 > 76  

Probieren Sie es online aus!

Kommentare

• Dies ist absurd effektiv, wie einfach es ist.
• Diese Lösung erzielte 63,5% die versteckten Testfälle, also ist es gültig.
• Nicht so einfach wie es am Anfang der Sandbox möglich war (100%, Kapitalisierungsunterschiede nutzen, bevor es standardisiert wurde), aber das ist wirklich einfach.
• @Mego Verbessert diese NSFW-Version aus Neugier die Punktzahl für die versteckten Testfälle? 🙂
• @Arnauld 66% mit dieser Version

Python 3, 84%

In versteckten Testfällen nicht getestet.

Hierbei wird Keras LSTM RNN verwendet, das in verschiedenen Überschriften trainiert wurde. Um es auszuführen, benötigen Sie Keras Folgendes und das Modell, das ich auf GitHub zur Verfügung gestellt habe: Repo-Link . Sie benötigen das Modell .h5 und die Wort- / Vektorzuordnungen befinden sich in .pkl. Die neuesten

Die Abhängigkeiten sind:

import numpy as np from pickle import load from keras.preprocessing import sequence, text from keras.models import Sequential from keras.layers import Dense, Embedding, SpatialDropout1D, LSTM, Dropout from keras.regularizers import l2 import re 

Die Einstellungen sind:

max_headline_length = 70 word_count = 20740 

Das Modell lautet:

model = Sequential() model.add(Embedding(word_count, 32, input_length=max_headline_length)) model.add(SpatialDropout1D(0.4)) model.add(LSTM(64, kernel_regularizer=l2(0.005), dropout=0.3, recurrent_dropout=0.3)) model.add(Dropout(0.5)) model.add(Dense(32, kernel_regularizer=l2(0.005))) model.add(Dropout(0.5)) model.add(Dense(2, kernel_regularizer=l2(0.001), activation="softmax")) 

Laden Sie nun das Modell und die Worteinbettungen:

model.load_weights("model.h5") word_to_index = load(open("words.pkl", "rb")) 

Und der Code zum Testen, ob eine Zeichenfolge von „NotTheOnion“ oder „TheOnion“ stammt „Ich habe eine schnelle Hilfsfunktion geschrieben, die die Zeichenfolge in die entsprechenden Worteinbettungen konvertiert:

def get_words(string): words = [] for word in re.finditer("[a-z]+|[\"".;/!?]", string.lower()): words.append(word.group(0)) return words def words_to_indexes(words): return [word_to_index.get(word, 0) for word in words] def format_input(word_indexes): return sequence.pad_sequences([word_indexes], maxlen=max_headline_length)[0] def get_type(string): words = words_to_indexes(get_words(string)) result = model.predict(np.array([format_input(words)]))[0] if result[0] > result[1]: site = "NotTheOnion" else: site = "TheOnion" return site 

Erläuterung

Dieser Code führt a aus Modell, das die Beziehungen zwischen Wörtern analysiert, indem die Wörter als „Vektor“ dargestellt werden. Weitere Informationen zum Einbetten von Wörtern finden Sie hier .

Dies wird in Überschriften trainiert, aber die Testfälle sind ausgeschlossen

Dieser Prozess wird nach einiger Verarbeitung automatisiert. Ich habe die endgültige Liste der verarbeiteten Wörter als .pkl verteilt, aber beim Einbetten von Wörtern analysieren wir zuerst den Satz und isolieren die Wörter.

Nachdem wir jetzt Wenn Sie die Wörter haben, besteht der nächste Schritt darin, die Unterschiede und Ähnlichkeiten zwischen bestimmten Wörtern zu verstehen, z. B. king und queen gegenüber duke und duchess. Diese Einbettungen finden nicht zwischen den tatsächlichen Wörtern statt, sondern zwischen Zahlen, die die Wörter darstellen, die in der Datei. Wörter, die die Maschine nicht versteht, werden einem speziellen Wort <UNK> zugeordnet, wodurch wir verstehen können, dass es dort ein Wort gibt, aber nicht genau bekannt ist, was die Bedeutung ist.

Nachdem die Wörter verstanden werden können, muss die Wortfolge (Überschrift) analysiert werden können. Dies ist, was „LSTM“ tut, ein LTSM ist eine Art „RNN“ -Zelle, die vermeidet den verschwindenden Verlaufseffekt. Einfacher gesagt, es wird eine Folge von Wörtern aufgenommen und es ermöglicht uns, Beziehungen zwischen ihnen zu finden.

Jetzt ist die letzte Ebene Dense was im Grunde bedeutet, dass es wie ein Array ist, was bedeutet, dass die Ausgabe wie folgt lautet: [probability_is_not_onion, probability_is_onion]. Indem wir herausfinden, welches größer ist, können wir auswählen, welches das sicherste Ergebnis für die angegebene Überschrift ist.

Python 3 + Keras, 41/50 = 82%

83% (166/200) bei versteckten Testfällen

import json import keras import numpy import re from keras import backend as K STRIP_PUNCTUATION = re.compile(r"[^a-z0-9 ]+") class AttentionWeightedAverage(keras.engine.Layer): def __init__(self, return_attention=False, **kwargs): self.init = keras.initializers.get("uniform") self.supports_masking = True self.return_attention = return_attention super(AttentionWeightedAverage, self).__init__(**kwargs) def build(self, input_shape): self.input_spec = [keras.engine.InputSpec(ndim=3)] assert len(input_shape) == 3 self.W = self.add_weight(shape=(input_shape[2], 1), name="{}_W".format(self.name), initializer=self.init) self.trainable_weights = [self.W] super(AttentionWeightedAverage, self).build(input_shape) def call(self, x, mask=None): logits = K.dot(x, self.W) x_shape = K.shape(x) logits = K.reshape(logits, (x_shape[0], x_shape[1])) ai = K.exp(logits - K.max(logits, axis=-1, keepdims=True)) if mask is not None: mask = K.cast(mask, K.floatx()) ai = ai * mask att_weights = ai / (K.sum(ai, axis=1, keepdims=True) + K.epsilon()) weighted_input = x * K.expand_dims(att_weights) result = K.sum(weighted_input, axis=1) if self.return_attention: return [result, att_weights] return result def get_output_shape_for(self, input_shape): return self.compute_output_shape(input_shape) def compute_output_shape(self, input_shape): output_len = input_shape[2] if self.return_attention: return [(input_shape[0], output_len), (input_shape[0], input_shape[1])] return (input_shape[0], output_len) def compute_mask(self, input, input_mask=None): if isinstance(input_mask, list): return [None] * len(input_mask) else: return None if __name__ == "__main__": model = keras.models.load_model("combined.h5", custom_objects={"AttentionWeightedAverage": AttentionWeightedAverage}) with open("vocabulary.json", "r") as fh: vocab = json.load(fh) while True: try: headline = input() except EOFError: break tokens = STRIP_PUNCTUATION.sub("", headline.lower()).split() inp = numpy.zeros((1, 45)) for i, token in enumerate(tokens): try: inp[0,i] = vocab[token] except KeyError: inp[0,i] = 1 print(model.predict(inp)[0][0] > 0.3) 

combined.h5 und vocabulary.json können hier (sehr groß) und iv id von abgerufen werden = „5324d3afac“>

JavaScript ( Node.js ), 98% (49/50)

96% (192/200) bei versteckten Testfällen

 const words = require("./words"); const bags = require("./bags"); let W = s => s.replace(/[^A-Za-z0-9 ]/g, "").toLowerCase().split(" ").filter(w => w.length > 3); let M = b => { for (let i = 0; i < bags.length; i++) { let f = true; for (let j = 0; j < bags[i].length; j++) if (!b.includes(bags[i][j])) { f = false; break; } if (f) return true; } return false; }; let O = s => { let b = []; W(s).forEach(w => { let p = words.indexOf(w); if (p >= 0) b.push(p); }); return (b.length > 0 && M(b)); };  

Dies erfordert zwei große JSON-Dateien, die ich nicht hier oder auf “ TiO . Bitte laden Sie sie von den folgenden Links herunter und speichern Sie sie mit den words.json und -Namen im selben Ordner wie die JS-Datei. Es gibt auch einen Link für eine JS-Datei mit Testfällen und Ergebnis / Prozent Druck.Sie können Ihre versteckten Testfälle in die Variablen onions und nonOnions einfügen.

• words.json
• bags.json
• onion.js (dies schließt Standardtestfälle ein)

Führen Sie nach dem Speichern aller 3 Dateien in demselben Verzeichnis .

Die Funktion O gibt true zurück, wenn es sich um Zwiebel und false wenn dies nicht der Fall ist. Verwendet eine große Liste von Wortbeuteln (ohne Reihenfolge), um festzustellen, ob die Eingabezeichenfolge Zwiebel ist. Art von hartcodiert, funktioniert aber sehr gut bei einer Vielzahl von Zufallstests Fälle.

Kommentare

• Diese Lösung erhält 96% für die versteckten Testfälle

Arnauld-Lösung abarbeiten

JavaScript (ES6), 41/50

64% (128/200) bei versteckt Testfälle

str.includes("Dad") || str.length ** .25 + str.split(" ").length ** 1.25 * 2 + str.split(/ly\b/).length ** 1.75 * 7 > 76 

JavaScript (ES6), 42/50

62,5% (125/200) bei versteckten Testfällen (ungültig)

isOnion = str => str.includes("Dad") || str.length ** .25 + str.split(" ").length ** 1.25 * 2 + str.split(" ").filter(w => w.length > 3 && w.split(/ly/).length > 1).length * 23.54 + /\d/.test(str) * 8 > 76 

Die Länge + Wortanzahl + „ly „Das Konzept funktioniert ziemlich gut. Ich konnte ein paar weitere Punkte herausgreifen, indem ich nach dem Wort“ Dad „(wann sprechen echte Artikel über die Väter der Leute in der dritten Person im Titel?) und einem zusätzlichen Punkt durch Ändern suchte Die „ly“ -Suchheuristik und die Überprüfung auf das Vorhandensein von Zahlen im Titel (die im allgemeinen Fall außerhalb des Tests möglicherweise weniger gültig sind, sodass ich beide Lösungen belassen habe)

Kommentare

• Ich ‚ weiß nichts über den Papa-Teil … scheint mir ein bisschen so, als würde ich den Testfall optimieren …