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

63,5% (127/200) rejtett teszteseteknél

Egyszerű heurisztika a cím hossza, a szóközök száma és a a -ly utótag használata.

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

Próbálja ki online!

Megjegyzések

• Ez abszurd módon hatékony, mennyire egyszerű.
• Ez a megoldás 63,5% -ot ért el a rejtett tesztesetek, így érvényes.
• Nem olyan egyszerű, mint amilyen a homokozó elején lehetséges volt (100%, a kis- és nagybetűs különbségeket kihasználva a szabványosítás előtt), de ez nagyon egyszerű.
• @Mego Csak kíváncsiságból javítja ez az NSFW verzió a rejtett tesztesetek pontszámát? 🙂
• @Arnauld 66% ezzel a verzióval

Python 3, 84%

Nem tesztelt rejtett teszteseteken.

Ez a különféle címsorokra betanított Keras LSTM RNN-t használja. A futtatásához szüksége van Kerasra és a következő modellre, amelyet elérhetővé tettem a GitHub-on: repo link . Szüksége lesz a és a szó / vektor leképezések .pkl fájlban vannak. A legújabb

A függőségek a következők:

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 

A beállítások a következők:

max_headline_length = 70 word_count = 20740 

A modell:

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")) 

Most a modell és a beágyazások beillesztéséhez:

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

És a teszteléshez szükséges kódot, ha egy karakterlánc a “NotTheOnion” vagy a “TheOnion” származik “Írtam egy gyors segítő függvényt, amely átalakítja a karakterláncot a szó beágyazásává:

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 

Magyarázat

Ez a kód egy modell, amely a szavak közötti kapcsolatokat úgy elemzi, hogy a szavakat “vektorként” ábrázolja. A szó beágyazásáról itt tudhat meg többet.

Ezt fejléceken oktatják, de a tesztesetek ki vannak zárva .

Ez a folyamat elég sok feldolgozás után automatizálódik. A végleges feldolgozott szólistát .pkl néven terjesztettem, de ami a szó beágyazásakor történik, először elemezzük a mondatot és elkülönítjük a szavakat.

Miután most a szavakkal a következő lépés az, hogy megértsük az egyes szavak közötti különbségeket és hasonlóságokat, pl. king és queen versus duke és duchess. Ezek a beágyazások nem a tényleges szavak, hanem a szavakat reprezentáló számok között történnek, ami a fájl. Azok a szavak, amelyeket a gép nem ért, egy speciális <UNK> szóhoz vannak hozzárendelve, amely lehetővé teszi számunkra, hogy megértsük, hogy van ott egy szó, de nem pontosan tudjuk, mi a jelentése.

Most, hogy a szavak megérthetők, elemezni kell a szavak sorrendjét (címsor). Ezt teszi az “LSTM”, az LTSM az “RNN” típusú cella, elkerüli az eltűnő gradiens hatást. Egyszerűbben, egy szósorozatot vesz fel, és lehetővé teszi számunkra, hogy kapcsolatokat találjunk közöttük.

Most az utolsó réteg Dense ami alapvetően azt jelenti, hogy egyfajta tömb, vagyis a kimenet olyan, mint: [probability_is_not_onion, probability_is_onion]. Megtalálva, melyik nagyobb, kiválaszthatjuk, hogy melyik legyen a legbiztosabb eredmény az adott címsorhoz.

Python 3 + Keras, 41/50 = 82%

83% (166/200) rejtett teszteseteknél

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 és vocabulary.json itt (nagyon nagy) és itt .

Teljesen összekapcsolt osztályozó egy előre kiképzett hangulatelemző modellhez csatlakozik, a DeepMoji, amely halmozott kétirányú LSTM-ekből és figyelmi mechanizmusból áll. Fagyasztottam a DeepMoji rétegeket, és kivettem a végső softmax réteget, csak a teljesen összekapcsolt rétegeket képeztem ki, majd feloldottam a DeepMoji rétegeket és együtt képeztem ki őket a finomhangoláshoz. A figyelem mechanizmusa a következőből származik: https://github.com/bfelbo/DeepMoji/blob/master/deepmoji/attlayer.py (nem akartam, hogy az összes kódjukat függőségként kell használni egy osztály számára, főleg, hogy Python 2, és meglehetősen nehézkes modulként használni …)

Ez meglepően gyengén teljesít a Mego tesztkészletén, tekintve, hogy a saját nagyobb érvényesítésemnél állítottam be > 90% -ot kap. Tehát még nem értem el ezzel.

Megjegyzések

• 83% rejtett tesztesetekre, feltéve, hogy jól futtattam

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

96% (192/200) rejtett teszteseteknél

 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)); };  

Ehhez két nagy JSON fájlra van szükség, amelyeket “nem tudok ide tenni, vagy ide rakni ” TiO “. Töltse le őket a következő linkekről, és mentse el őket a words.json és a nevek, ugyanabban a mappában, mint a JS fájl. Van egy link egy JS fájlhoz, amely tartalmazza a teszteseteket és az eredmény / százalékos nyomtatást.A rejtett teszteseteket elhelyezheti onions és nonOnions változókban.

• words.json
• bags.json
• onion.js (ide tartoznak az alapértelmezett tesztesetek is)

Miután mindhárom fájlt elmentette ugyanabba a könyvtárba, futtassa a .

A O függvény visszaadja true ha ez hagyma és false ha nem “t”. A szózsákok nagy listáját használja (sorrend nélkül) annak észlelésére, hogy a beviteli karakterlánc hagymás. Kemény kódolású, de nagyon jól működik különféle véletlenszerű teszteken esetek.

Megjegyzések

• Ez a megoldás a rejtett tesztesetek 96% -át kapja

Arnauld megoldásának kidolgozása

JavaScript (ES6), 41/50

64% (128/200) rejtetten tesztesetek

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) a rejtett teszteseteknél (érvénytelen)

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 

A hosszúság + szószám + “ly “a koncepció elég jól működik, tudtam még néhány pontot kipréselni azzal, hogy megvizsgáltam az” Apa “szót (amikor a valódi cikkek az emberek apáiról beszélnek a címben szereplő harmadik személyben?) és egy további pontot azáltal, hogy megváltoztattam a “ly” keresési heurisztika és a címben szereplő számok ellenőrzése (ami általában kevésbé érvényes a teszten kívül, ezért mindkét megoldást hagytam)

Megjegyzések

• Nem tudok ‘ nem tudok az apa részéről … nekem egy kicsit úgy tűnik, mintha a tesztesetet optimalizálnám …
• És igen, rengeteg Nem hagyma cikket találok, amelyek apákat említenek
• Ott ‘ valószínűleg jobb módszer a heurisztika részeként. és nem csak egy kemény ” win ” ha apát tartalmaz, de elképzelhetőnek tartom, hogy még a tesztadatbázison kívül is elvontan beszélünk egy adott