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

63,5% (127/200) piilotetuissa testitapauksissa

Yksinkertainen heuristinen otsikon pituuden, välilyöntien ja -ly -liitteen käyttö.

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

Kokeile verkossa!

Kommentit

• Tämä on järjetöntä, kuinka yksinkertaista se on.
• Tämä ratkaisu sai 63,5% piilotetut testitapaukset, joten se on kelvollinen.
• Ei niin yksinkertaista kuin mahdollista hiekkalaatikon alussa (100%, hyödyntämällä isojen kirjainten erot ennen standardointia), mutta tämä on todella yksinkertaista.
• @Mego parantaako

Python 3, 84%

Ei testattu piilotetuissa testitapauksissa.

Tämä käyttää eri otsikoihin koulutettua Keras LSTM RNN -ohjelmaa. Sen suorittamiseen tarvitaan seuraavat Keras ja malli, jonka olen asettanut saataville GitHubissa: repolinkki . Tarvitset mallin .h5 ja sana- / vektorikartoitukset ovat .pkl. Uusimmat

Riippuvuudet ovat:

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 

Asetukset ovat:

max_headline_length = 70 word_count = 20740 

Malli on:

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

Lataa nyt malli ja sanojen upotukset:

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

Ja koodi, jolla testataan, onko merkkijono peräisin NotTheOnionista tai TheOnionista ”Olen kirjoittanut pika-aputoiminnon, joka muuntaa merkkijonon vastaaviksi sanojen upotuksiksi:

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 

Selitys

Tämä koodi suorittaa malli, joka analysoi sanojen välisiä suhteita edustamalla sanoja ”vektorina”. Voit oppia lisää sanojen upottamisesta täältä .

Tämä on koulutettu otsikoihin, mutta testitapaukset eivät kuulu .

Tämä prosessi automatisoidaan melkoisen käsittelyn jälkeen. Olen jakanut lopullisen käsitellyn sanaluettelon .pkl, mutta sanojen upottamisessa tapahtuu ensin analysoimme lause ja eristämme sanat.

Kun nyt on sanat seuraava askel on ymmärtää eroja ja samankaltaisuuksia tiettyjen sanojen välillä, esim. king ja queen vs. duke ja duchess. Nämä upotukset eivät tapahdu varsinaisten sanojen välillä, vaan sanoja edustavien numeroiden välillä, mikä on tallennettu kansioon .pkl -tiedosto. Sanat, joita kone ei ymmärrä, yhdistetään erityiseen sanaan <UNK>, jonka avulla voimme ymmärtää, että siellä on sana, mutta että ei tiedetä tarkalleen mitä merkitys on. / p>

Nyt kun sanat voidaan ymmärtää, sanasekvenssi (otsikko) on voitava analysoida. Tätä ”LSTM” tekee. LTSM on ”RNN” -solutyyppi, joka välttää katoavan gradienttivaikutuksen. Yksinkertaisemmin se vie sanasarjan ja sen avulla voimme löytää suhteita niiden välillä.

Nyt viimeinen kerros on Dense mikä tarkoittaa pohjimmiltaan sen tyyppistä matriisia, mikä tarkoittaa, että lähtö on kuin: [probability_is_not_onion, probability_is_onion]. Löytämällä kumpi on suurempi, voimme valita, mikä on luotettavin tulos annetulle otsikolle.

Python 3 + Keras, 41/50 = 82%

83% (166/200) piilotetuissa testitapauksissa

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 ja vocabulary.json voidaan hakea täältä (erittäin suuri) ja täällä .

Täysin kytketty luokittelija, joka on liitetty ennalta koulutettuun mielipiteen analyysimalliin DeepMoji, joka koostuu pinotuista kaksisuuntaisista LSTM: istä ja tarkkailumekanismista. Jäädytin DeepMoji-kerrokset ja otin lopullisen softmax-kerroksen, koulutin vain täysin kytketyt kerrokset, sitten sulasin DeepMoji-kerrokset ja koulutin ne yhteen hienosäätöä varten. Tarkkailumekanismi on otettu kohdasta https://github.com/bfelbo/DeepMoji/blob/master/deepmoji/attlayer.py (en halunnut joutua käyttämään kaikkia koodejaan riippuvuutena yhdelle luokalle, varsinkin kun se on Python 2 ja melko hankala käyttää moduulina …)

Tämä toimii yllättävän huonosti Megon testisarjassa, kun otetaan huomioon, että asetin sen omalla suuremmalla vahvistuksellani saa> 90%. Joten en ole vielä tehnyt tätä.

Kommentit

• 83% piilotetuista testitapauksista, olettaen, että suoritin sen oikein

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

96% (192/200) piilotetuissa testitapauksissa

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

Tämä vaatii kaksi isoa JSON-tiedostoa, joita en voi laittaa tänne tai ” TiO ”. Lataa ne seuraavista linkeistä ja tallenna ne words.json ja nimet, samassa kansiossa kuin JS-tiedosto. Siellä on myös linkki JS-tiedostolle, jossa on testitapauksia ja tulos / prosenttiosuus.Voit laittaa piilotetut testitapaukset onions – ja nonOnions -muuttujiin.

• words.json
• bags.json
• onion.js (tämä sisältää oletusarvoiset testitapaukset)

Kun olet tallentanut kaikki 3 tiedostoa samaan hakemistoon, suorita node onion.js.

O -funktio palauttaa true jos se on sipuli ja false jos se ei ole ””. Suuren luettelon sanapusseista (ilman järjestystä) havaitaan, onko syötetty merkkijono sipuli. Eräänlainen kovakoodattu, mutta toimii hyvin erilaisissa satunnaisissa testeissä tapauksia.

Kommentit

• Tämä ratkaisu saa 96% piilotetuista testitapauksista

Arnauldin ratkaisun käyttäminen

JavaScript (ES6), 41/50

64% (128/200) piilossa testitapaukset

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) piilotetuissa testitapauksissa (virheellinen)

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 

Pituus + sanamäärä + ”ly ”käsite toimii melko hyvin, pystyin puristamaan vielä muutaman pisteen tarkistamalla sanan” Isä ”(milloin todelliset artikkelit puhuvat ihmisten isistä otsikossa kolmannessa persoonassa?) Ja lisäpisteen muuttamalla ”ly” -hakuuristinen ja numeroiden esiintymisen tarkistaminen otsikossa (mikä saattaa olla vähemmän pätevää testin ulkopuolella, joten jätin molemmat ratkaisut)

Kommentit

• En tiedä ’ en tiedä isäosasta … näyttää siltä, että minulle olisi optimoitu testitapausta …
• Ja kyllä, löydän paljon Ei sipulia -artikkeleita, joissa mainitaan isät
• Siellä ’ on luultavasti parempi tapa tehdä se osana heuristista eikä vain kova ” win ” jos se sisältää isää, mutta kuvittelen jopa testitietokannan ulkopuolella abstraktisti puhuvan tietystä ” Isä ” on yleisempi sipulilla
• Ensimmäinen ratkaisusi sai 64% piilotetuista testitapauksista, joten se on kelvollinen. Toinen ratkaisusi sai 62,5% piilotetuista testitapauksista, joten se ei ole kelvollinen.
• @Mego Mikä lähellä marginaalia …