Jak zbudować model, aby odróżnić tweety o Apple (Inc.) od tweetów o jabłkach (owocach)?

Zobacz poniżej 50 tweetów na temat „Apple”. Odręcznie oznaczyłem pozytywne dopasowania dotyczące Apple Inc. Są one poniżej oznaczone jako 1.

Oto kilka linijek:

1|“@chrisgilmer: Apple targets big business with new iOS 7 features http://bit.ly/15F9JeF ”. Finally.. A corp iTunes account!
0|“@Zach_Paull: When did green skittles change from lime to green apple? #notafan” @Skittles
1|@dtfcdvEric: @MaroneyFan11 apple inc is searching for people to help and tryout all their upcoming tablet within our own net page No.
0|@STFUTimothy have you tried apple pie shine?
1|#SuryaRay #India Microsoft to bring Xbox and PC games to Apple, Android phones: Report: Microsoft Corp... http://dlvr.it/3YvbQx  @SuryaRay

Oto całkowity zestaw danych: http://pastebin.com/eJuEb4eB

Muszę zbudować model klasyfikujący „Apple” (Inc). od reszty.

Nie szukam ogólnego przeglądu uczenia maszynowego, raczej szukam rzeczywistego modelu w kodzie ( preferowany Python ).

Zrobiłbym to w następujący sposób:

1. Podziel zdanie na słowa, znormalizuj je, zbuduj słownik
2. Z każdym słowem zapisz ile razy pojawiły się one w tweetach o firmie, a ile razy pojawiły się w tweetach o owocach - te tweety muszą być potwierdzone przez człowieka
3. Kiedy pojawia się nowy tweet, znajdź każde słowo w tweecie w słowniku, oblicz wynik ważony - słowa, które są często używane w odniesieniu do firmy, uzyskałyby wysoki wynik firmy i odwrotnie; słowa używane rzadko lub używane zarówno w towarzystwie, jak iw owocach, nie miałyby dużej punktacji.

To, czego szukasz, nazywa się Rozpoznawanie nazwanych jednostek . Jest to technika statystyczna, która (najczęściej) wykorzystuje warunkowe pola losowe do znajdowania nazwanych jednostek na podstawie przeszkolenia w zakresie uczenia się o nazwanych jednostkach.

Zasadniczo analizuje zawartość i kontekst słowa (patrząc wstecz i do przodu kilka słów), aby oszacować prawdopodobieństwo, że słowo jest nazwaną jednostką.

Dobre oprogramowanie może analizować inne cechy słów, takie jak długość lub kształt (np. „Vcv”, jeśli zaczyna się od „samogłoska-spółgłoska-samogłoska”)

Bardzo dobrą biblioteką (GPL) jest NER Stanforda

Oto demo: http://nlp.stanford.edu:8080/ner/

Przykładowy tekst do wypróbowania:

Jadłem jabłko w siedzibie Apple i pomyślałem o Apple Martin, córce faceta z Coldplay

(klasyfikatory 3class i 4class dobrze to rozumieją)

Mam częściowo działający system, który rozwiązuje ten problem, oparty na otwartym kodzie źródłowym za pomocą scikit-learn, z serią postów na blogu opisujących to, co robię. Problem, z którym się zmagam, to ujednoznacznienie w sensie słów (wybranie jednej z wielu opcji sensu słów ), co nie jest tym samym, co Rozpoznawanie nazwanych jednostek. Moje podstawowe podejście jest nieco konkurencyjne w stosunku do istniejących rozwiązań i (co najważniejsze) można je dostosowywać.

Istnieje kilka istniejących komercyjnych narzędzi NER (OpenCalais, DBPedia Spotlight i AlchemyAPI), które mogą dać wystarczająco dobry wynik komercyjny - wypróbuj je najpierw!

Część z nich wykorzystałem do projektu klienta (konsultuję się przy użyciu NLP / ML w Londynie), ale nie byłem zadowolony z ich wycofania ( precyzja i przywołanie ). Zasadniczo mogą być precyzyjne (kiedy mówią „To jest Apple Inc”, zazwyczaj są poprawne), ale z niską pamięcią (rzadko mówią „To jest Apple Inc”, chociaż dla człowieka tweet dotyczy oczywiście Apple Inc). Pomyślałem, że zbudowanie wersji open source dostosowanej do tweetów byłoby interesującym intelektualnie ćwiczeniem. Oto aktualny kod: https://github.com/ianozsvald/social_media_brand_disambiguator

Zauważę - nie próbuję rozwiązywać uogólnionego problemu ujednoznaczniania sensu słów za pomocą tego podejścia, tylko ujednoznacznienie marki (firmy, ludzie itp.), Kiedy już masz ich nazwę. Dlatego uważam, że to proste podejście zadziała.

Zacząłem to sześć tygodni temu i jest napisane w Pythonie 2.7 przy użyciu scikit-learn. Wykorzystuje bardzo podstawowe podejście. Wektoryzuję za pomocą binarnego wektoryzatora liczenia (liczę tylko, czy pojawi się słowo, a nie ile razy) z 1-3  n-gramami . Nie skaluję z TF-IDF (TF-IDF jest dobry, gdy masz zmienną długość dokumentu; dla mnie tweety to tylko jedno lub dwa zdania, a moje wyniki testów nie wykazały poprawy z TF-IDF).

Używam podstawowego tokenizera, który jest bardzo prosty, ale zaskakująco przydatny. Ignoruje @ # (więc tracisz kontekst) i oczywiście nie rozwija adresu URL. Następnie trenuję przy użyciu regresji logistycznej i wydaje się, że ten problem jest nieco liniowy (wiele terminów dla jednej klasy nie istnieje dla drugiej). Obecnie unikam wszelkiego wyprowadzania / czyszczenia (próbuję najprostszej możliwej rzeczy, która może zadziałać).

Kod ma pełne README i powinieneś być w stanie stosunkowo łatwo przyswoić swoje tweety, a następnie postępować zgodnie z moimi sugestiami dotyczącymi testowania.

Działa to w przypadku Apple, ponieważ ludzie nie jedzą ani nie piją komputerów Apple, ani nie piszemy ani nie bawimy się owocami, więc słowa można łatwo podzielić na jedną lub drugą kategorię. Ten warunek może nie obowiązywać, gdy rozważa się coś w rodzaju #definance dla programu telewizyjnego (gdzie ludzie używają również #definance w odniesieniu do Arabskiej Wiosny, meczów krykieta, powtórzenia egzaminów i zespołu muzycznego). W tym przypadku może być wymagane podejście Cleverer.

Mam serię postów na blogu opisujących ten projekt, w tym godzinną prezentację, którą wygłosiłem na grupie użytkowników BrightonPython (która zamieniła się w krótszą prezentację dla 140 osób w DataScienceLondon).

Jeśli używasz czegoś takiego jak Regresja Logistyczna (gdzie uzyskujesz prawdopodobieństwo dla każdej klasyfikacji), możesz wybrać tylko pewne klasyfikacje iw ten sposób możesz wymusić wysoką precyzję, handlując przeciwko wycofaniu (dzięki czemu uzyskasz prawidłowe wyniki, ale ich mniej). Będziesz musiał dostroić to do swojego systemu.

Oto możliwe podejście algorytmiczne wykorzystujące scikit-learn:

• Użyj Binary CountVectorizer (nie sądzę, aby liczba terminów w krótkich wiadomościach dodawała dużo informacji, ponieważ większość słów występuje tylko raz)
• Zacznij od klasyfikatora drzewa decyzyjnego. Będzie miał możliwą do wyjaśnienia wydajność (zobacz przykład nadmiernego dopasowania za pomocą drzewa decyzyjnego ).
• Przejdź do regresji logistycznej
• Zbadaj błędy generowane przez klasyfikatory (przeczytaj wyeksportowane dane wyjściowe DecisionTree lub spójrz na współczynniki w LogisticRegression, przeprowadź błędnie sklasyfikowane tweety z powrotem przez Vectorizer, aby zobaczyć, jak wygląda podstawowa reprezentacja Bag of Words - będzie tam mniej tokenów niż zacząłeś w surowym tweecie - czy wystarczy na klasyfikację?)
• Spójrz na mój przykładowy kod w https://github.com/ianozsvald/social_media_brand_disambiguator/blob/master/learn1.py, aby uzyskać działającą wersję tego podejścia

Rzeczy do rozważenia:

• Potrzebujesz większego zbioru danych. Używam 2000 oznaczonych tweetów (zajęło mi to pięć godzin) i jako minimum chcesz zbalansowanego zestawu z> 100 na klasę (patrz uwaga o przeuczeniu poniżej)
• Ulepsz tokeniser (bardzo łatwy dzięki scikit-learn), aby zachować # @ w tokenach i być może dodaj detektor marki z wielką literą (jako notatki user @ user2425429)
• Rozważ nieliniowy klasyfikator (jak sugestia @ oiez powyżej), gdy sprawy stają się trudniejsze. Osobiście uważam, że LinearSVC radzi sobie gorzej niż regresja logistyczna (ale może to wynikać z wielowymiarowej przestrzeni funkcji, której jeszcze nie zmniejszyłem).
• Specyficzna dla tweeta część taggera mowy (moim skromnym zdaniem nie Standforda, jak sugeruje @Neil - z mojego doświadczenia wynika, że ​​słabo działa na słabej gramatyce na Twitterze)
• Gdy będziesz mieć dużo tokenów, prawdopodobnie zechcesz zmniejszyć wymiarowość (jeszcze tego nie próbowałem - zobacz mój wpis na blogu na temat kary LogisticRegression l1 l2)

Re. przeładowanie. W moim zbiorze danych zawierającym 2000 pozycji mam 10-minutową migawkę z Twittera tweetów „Apple”. Około 2/3 tweetów jest dla Apple Inc, 1/3 dla innych zastosowań Apple. Wyciągam zrównoważony podzbiór (myślę, że około 584 wierszy) z każdej klasy i przeprowadzam pięciokrotną weryfikację krzyżową na potrzeby treningu.

Ponieważ mam tylko 10-minutowe okno czasowe, mam wiele tweetów na ten sam temat i prawdopodobnie dlatego mój klasyfikator radzi sobie tak dobrze w porównaniu z istniejącymi narzędziami - będzie zbyt dobrze dopasowany do funkcji szkoleniowych bez dobrego uogólniania (podczas gdy istniejący komercyjny narzędzia działają gorzej w tym sklepie snapshop, ale bardziej niezawodnie w szerszym zestawie danych). Rozszerzę moje okno czasowe, aby przetestować to jako kolejną część pracy.

Możesz wykonać następujące czynności:

1. Stwórz dyktando słów zawierających liczbę ich występowania w tweetach owocowych i firmowych. Można to osiągnąć, podając mu kilka przykładowych tweetów, których skłonności znamy.

2. Korzystając z wystarczającej ilości wcześniejszych danych, możemy ustalić prawdopodobieństwo wystąpienia słowa w tweecie o Apple Inc.

3. Pomnóż indywidualne prawdopodobieństwa słów, aby otrzymać prawdopodobieństwo całego tweeta.

Uproszczony przykład:

p_f = Prawdopodobieństwo tweetów owocowych.

p_w_f = Prawdopodobieństwo wystąpienia słowa w tweecie owocowym.

p_t_f = Połączone prawdopodobieństwo, że wszystkie słowa w tweecie wystąpią w tweecie owocowym = p_w1_f * p_w2_f * ...

p_f_t = Prawdopodobieństwo otrzymania owocu w danym tweecie .

p_c, p_w_c, p_t_c, p_c_t to odpowiednie wartości dla firmy.

Dodawany jest laplaciański wygładzacz o wartości 1, aby wyeliminować problem zerowej częstotliwości nowych słów, których nie ma w naszej bazie danych.

old_tweets = {'apple pie sweet potatoe cake baby https://vine.co/v/hzBaWVA3IE3': '0', ...}
known_words = {}
total_company_tweets = total_fruit_tweets =total_company_words = total_fruit_words = 0

for tweet in old_tweets:
    company = old_tweets[tweet]
    for word in tweet.lower().split(" "):
        if not word in known_words:
            known_words[word] = {"company":0, "fruit":0 }
        if company == "1":
            known_words[word]["company"] += 1
            total_company_words += 1
        else:
            known_words[word]["fruit"] += 1
            total_fruit_words += 1

    if company == "1":
        total_company_tweets += 1
    else:
        total_fruit_tweets += 1
total_tweets = len(old_tweets)

def predict_tweet(new_tweet,K=1):
    p_f = (total_fruit_tweets+K)/(total_tweets+K*2)
    p_c = (total_company_tweets+K)/(total_tweets+K*2)
    new_words = new_tweet.lower().split(" ")

    p_t_f = p_t_c = 1
    for word in new_words:
        try:
            wordFound = known_words[word]
        except KeyError:
            wordFound = {'fruit':0,'company':0}
        p_w_f = (wordFound['fruit']+K)/(total_fruit_words+K*(len(known_words)))
        p_w_c = (wordFound['company']+K)/(total_company_words+K*(len(known_words)))
    p_t_f *= p_w_f
    p_t_c *= p_w_c

    #Applying bayes rule
    p_f_t = p_f * p_t_f/(p_t_f*p_f + p_t_c*p_c)
    p_c_t = p_c * p_t_c/(p_t_f*p_f + p_t_c*p_c)
    if p_c_t > p_f_t:
        return "Company"
    return "Fruit"

Jeśli nie masz problemu z używaniem zewnętrznej biblioteki, polecam scikit-learn, ponieważ prawdopodobnie może to zrobić lepiej i szybciej niż cokolwiek, co możesz sam kodować. Po prostu zrobiłbym coś takiego:

Zbuduj swój korpus. Zrobiłem listę składaną dla przejrzystości, ale w zależności od sposobu przechowywania danych może być konieczne wykonanie różnych czynności:

def corpus_builder(apple_inc_tweets, apple_fruit_tweets):
    corpus = [tweet for tweet in apple_inc_tweets] + [tweet for tweet in apple_fruit_tweets]
    labels = [1 for x in xrange(len(apple_inc_tweets))] + [0 for x in xrange(len(apple_fruit_tweets))]
    return (corpus, labels)

Ważne jest to, że otrzymasz dwie listy, które wyglądają następująco:

([['apple inc tweet i love ios and iphones'], ['apple iphones are great'], ['apple fruit tweet i love pie'], ['apple pie is great']], [1, 1, 0, 0])

[1, 1, 0, 0] reprezentują etykiety dodatnie i ujemne.

Następnie tworzysz Pipeline! Pipeline to klasa typu scikit-learning, która ułatwia łączenie etapów przetwarzania tekstu w łańcuchy, dzięki czemu podczas treningu / przewidywania wystarczy wywołać tylko jeden obiekt:

def train(corpus, labels)
    pipe = Pipeline([('vect', CountVectorizer(ngram_range=(1, 3), stop_words='english')),
                        ('tfidf', TfidfTransformer(norm='l2')),
                        ('clf', LinearSVC()),])
    pipe.fit_transform(corpus, labels)
    return pipe

Wewnątrz potoku znajdują się trzy etapy przetwarzania. CountVectorizer tokenizuje słowa, dzieli je, zlicza i przekształca dane w rzadką macierz. TfidfTransformer jest opcjonalny i możesz chcieć go usunąć w zależności od oceny dokładności (przeprowadzanie testów walidacji krzyżowej i wyszukiwanie najlepszych parametrów w siatce jest trochę zaangażowane, więc nie będę się tutaj wdawać). LinearSVC to standardowy algorytm klasyfikacji tekstu.

Na koniec przewidujesz kategorię tweetów:

def predict(pipe, tweet):
    prediction = pipe.predict([tweet])
    return prediction

Znowu tweet musi znajdować się na liście, więc założyłem, że wpisuje funkcję jako ciąg.

Umieść je na zajęciach lub cokolwiek innego i gotowe. Przynajmniej w tym bardzo podstawowym przykładzie.

Nie testowałem tego kodu, więc może nie zadziałać, jeśli po prostu skopiujesz i wkleisz, ale jeśli chcesz użyć scikit-learn, powinno dać ci pomysł, od czego zacząć.

EDYCJA: próbowałem bardziej szczegółowo wyjaśnić kroki.

Wydaje się, że użycie drzewa decyzyjnego działa całkiem dobrze w przypadku tego problemu. Przynajmniej zapewnia wyższą dokładność niż naiwny klasyfikator Bayesa z wybranymi przeze mnie funkcjami.

Jeśli chcesz pobawić się niektórymi możliwościami, możesz użyć następującego kodu, który wymaga zainstalowania nltk. Książka nltk jest również dostępna bezpłatnie online, więc możesz przeczytać trochę o tym, jak to wszystko faktycznie działa: http://nltk.googlecode.com/svn/trunk/doc/book/ch06.html

#coding: utf-8
import nltk
import random
import re

def get_split_sets():
    structured_dataset = get_dataset()
    train_set = set(random.sample(structured_dataset, int(len(structured_dataset) * 0.7)))
    test_set = [x for x in structured_dataset if x not in train_set]

    train_set = [(tweet_features(x[1]), x[0]) for x in train_set]
    test_set = [(tweet_features(x[1]), x[0]) for x in test_set]
    return (train_set, test_set)

def check_accurracy(times=5):
    s = 0
    for _ in xrange(times):
        train_set, test_set = get_split_sets()
        c = nltk.classify.DecisionTreeClassifier.train(train_set)
        # Uncomment to use a naive bayes classifier instead
        #c = nltk.classify.NaiveBayesClassifier.train(train_set)
        s += nltk.classify.accuracy(c, test_set)

    return s / times


def remove_urls(tweet):
    tweet = re.sub(r'http:\/\/[^ ]+', "", tweet)
    tweet = re.sub(r'pic.twitter.com/[^ ]+', "", tweet)
    return tweet

def tweet_features(tweet):
    words = [x for x in nltk.tokenize.wordpunct_tokenize(remove_urls(tweet.lower())) if x.isalpha()]
    features = dict()
    for bigram in nltk.bigrams(words):
        features["hasBigram(%s)" % ",".join(bigram)] = True
    for trigram in nltk.trigrams(words):
        features["hasTrigram(%s)" % ",".join(trigram)] = True  
    return features

def get_dataset():
    dataset = """copy dataset in here
"""
    structured_dataset = [('fruit' if x[0] == '0' else 'company', x[2:]) for x in dataset.splitlines()]
    return structured_dataset

if __name__ == '__main__':
    print check_accurracy()

Dziękuję za dotychczasowe komentarze. Oto działające rozwiązanie, które przygotowałem w PHP. Nadal chciałbym usłyszeć od innych bardziej algorytmiczne podejście do tego samego rozwiązania.

<?php

// Confusion Matrix Init
$tp = 0;
$fp = 0;
$fn = 0;
$tn = 0;
$arrFP = array();
$arrFN = array();

// Load All Tweets to string
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'http://pastebin.com/raw.php?i=m6pP8ctM');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$strCorpus = curl_exec($ch);
curl_close($ch);

// Load Tweets as Array
$arrCorpus = explode("\n", $strCorpus);
foreach ($arrCorpus as $k => $v) {
    // init
    $blnActualClass = substr($v,0,1);
    $strTweet = trim(substr($v,2));

    // Score Tweet
    $intScore = score($strTweet);

    // Build Confusion Matrix and Log False Positives & Negatives for Review
    if ($intScore > 0) {
        if ($blnActualClass == 1) {
            // True Positive
            $tp++;
        } else {
            // False Positive
            $fp++;
            $arrFP[] = $strTweet;
        }
    } else {
        if ($blnActualClass == 1) {
            // False Negative
            $fn++;
            $arrFN[] = $strTweet;
        } else {
            // True Negative
            $tn++;
        }
    }
}

// Confusion Matrix and Logging
echo "
           Predicted
            1     0
Actual 1   $tp     $fp
Actual 0    $fn    $tn

";

if (count($arrFP) > 0) {
    echo "\n\nFalse Positives\n";
    foreach ($arrFP as $strTweet) {
        echo "$strTweet\n";
    }
}

if (count($arrFN) > 0) {
    echo "\n\nFalse Negatives\n";
    foreach ($arrFN as $strTweet) {
        echo "$strTweet\n";
    }
}

function LoadDictionaryArray() {
    $strDictionary = <<<EOD
10|iTunes
10|ios 7
10|ios7
10|iPhone
10|apple inc
10|apple corp
10|apple.com
10|MacBook
10|desk top
10|desktop
1|config
1|facebook
1|snapchat
1|intel
1|investor
1|news
1|labs
1|gadget
1|apple store
1|microsoft
1|android
1|bonds
1|Corp.tax
1|macs
-1|pie
-1|clientes
-1|green apple
-1|banana
-10|apple pie
EOD;

    $arrDictionary = explode("\n", $strDictionary);
    foreach ($arrDictionary as $k => $v) {
        $arr = explode('|', $v);
        $arrDictionary[$k] = array('value' => $arr[0], 'term' => strtolower(trim($arr[1])));
    }
    return $arrDictionary;
}

function score($str) {
    $str = strtolower($str);
    $intScore = 0;
    foreach (LoadDictionaryArray() as $arrDictionaryItem) {
        if (strpos($str,$arrDictionaryItem['term']) !== false) {
            $intScore += $arrDictionaryItem['value'];
        }
    }
    return $intScore;
}
?>

Powyższe wyniki:

           Predicted
            1     0
Actual 1   31     1
Actual 0    1    17


False Positives
1|Royals apple #ASGame @mlb @ News Corp Building http://instagram.com/p/bBzzgMrrIV/


False Negatives
-1|RT @MaxFreixenet: Apple no tiene clientes. Tiene FANS// error.... PAGAS por productos y apps, ergo: ERES CLIENTE.

We wszystkich podanych przez Ciebie przykładach Apple (inc) było określane jako A pple lub apple inc , więc możliwym sposobem może być wyszukanie:

• duże „A” w Apple

• „inc” po jabłku

• słowa / wyrażenia, takie jak „OS”, „system operacyjny”, „Mac”, „iPhone”, ...

• lub ich połączenie

Aby nieco uprościć odpowiedzi oparte na warunkowych polach losowych ... kontekst jest tutaj ogromny. Będziesz chciał wybrać w tych tweetach, które wyraźnie pokazują Apple, firmę kontra jabłko owoc. Pozwólcie, że przedstawię tutaj listę funkcji, które mogą być przydatne na początku. Aby uzyskać więcej informacji, poszukaj fragmentów wyrażeń rzeczownikowych i czegoś, co nazywa się etykietami BIO. Zobacz ( http://www.cis.upenn.edu/~pereira/papers/crf.pdf )

Otaczające słowa: stwórz wektor cech dla poprzedniego i następnego słowa lub, jeśli chcesz mieć więcej funkcji, na przykład dla poprzednich 2 i następnych 2 słów. Nie chcesz zbyt wielu słów w modelu lub nie będzie on dobrze pasował do danych. W przetwarzaniu języka naturalnego będziesz chciał, aby to było jak najbardziej ogólne.

Inne funkcje, które można uzyskać z otaczających słów, obejmują:

Czy pierwsza postać jest stolicą

Czy ostatni znak w słowie jest kropką

Część mowy słowa (Wyszukaj część oznaczania mowy)

Sam tekst słowa

Nie radzę tego, ale podaję więcej przykładów funkcji specjalnie dla Apple:

WordIs (Apple)

NextWordIs (Inc.)

Dostajesz punkt. Pomyśl o rozpoznawaniu nazwanych jednostek jako opisie sekwencji, a następnie używając matematyki, aby powiedzieć komputerowi, jak to obliczyć.

Należy pamiętać, że przetwarzanie języka naturalnego jest systemem opartym na potokach. Zazwyczaj dzielisz rzeczy na zdania, przechodzisz do tokenizacji, a następnie wykonujesz część tagowania mowy, a nawet parsowania zależności.

To wszystko po to, aby uzyskać listę funkcji, których możesz użyć w swoim modelu, aby zidentyfikować to, czego szukasz.

W Pythonie jest naprawdę dobra biblioteka do przetwarzania tekstu w języku naturalnym o nazwie nltk. Powinieneś się temu przyjrzeć.

Jedną ze strategii, którą możesz wypróbować, jest przyjrzenie się n-gramom (grupom słów) ze słowem „jabłko”. Niektórych słów częściej używa się obok słowa „jabłko”, gdy mówi się o owocach, innych, gdy mówi się o firmie, i można ich użyć do sklasyfikowania tweetów.

Użyj LibShortText . To narzędzie Pythona zostało już dostrojone do pracy z zadaniami kategoryzacji krótkiego tekstu i działa dobrze. Maksymalne, które musisz zrobić, to napisać pętlę, aby wybrać najlepszą kombinację flag. Użyłem go do nadzorowanej klasyfikacji aktów mowy w e-mailach, a wyniki były dokładne do 95-97% (podczas 5-krotnej weryfikacji krzyżowej!).

I pochodzi od twórców LIBSVM i LIBLINEAR, których implementacja maszyny wektorów nośnych (SVM) jest używana w sklearn i cran, więc możesz mieć uzasadnioną pewność, że ich implementacja nie zawiera błędów.

Utwórz filtr AI, aby odróżnić Apple Inc (firmę) od Apple (owoc). Ponieważ są to tweety, zdefiniuj zestaw treningowy za pomocą wektora 140 pól, z których każde jest znakiem wpisanym w tweecie na pozycji X (od 0 do 139). Jeśli tweet jest krótszy, podaj po prostu wartość pustą.

Następnie zbuduj zestaw treningowy wystarczająco duży, aby uzyskać dobrą dokładność (subiektywną do gustu). Przypisz wartość wyniku do każdego tweeta, tweet Apple Inc otrzyma 1 (prawda), a tweet jabłka (owoc) otrzyma 0. Byłby to przypadek nadzorowanego uczenia się w regresji logistycznej .

To jest uczenie maszynowe, które jest ogólnie łatwiejsze do kodowania i działa lepiej. Musi się uczyć z zestawu, który mu dajesz, i nie jest zakodowany na stałe.

Nie znam Pythona , więc nie mogę napisać do niego kodu, ale gdybyś poświęcił więcej czasu na logikę i teorię uczenia maszynowego, możesz spojrzeć na klasę, którą śledzę.

Wypróbuj kurs Coursera Machine Learning autorstwa Andrew Ng . Nauczysz się uczenia maszynowego na MATLAB-ie lub Octave , ale kiedy już opanujesz podstawy, będziesz w stanie pisać uczenie maszynowe w dowolnym języku, jeśli rozumiesz prostą matematykę (prostą w regresji logistycznej).

Oznacza to, że pobranie kodu od kogoś nie sprawi, że będziesz w stanie zrozumieć, co dzieje się w kodzie uczenia maszynowego. Możesz poświęcić kilka godzin na ten temat, aby zobaczyć, co się naprawdę dzieje.

Zalecałbym unikanie odpowiedzi sugerujących uznanie jednostek. Ponieważ to zadanie to najpierw klasyfikacja tekstu, a dopiero potem rozpoznawanie jednostek (możesz to zrobić w ogóle bez rozpoznawania jednostek).

Myślę, że najszybszą drogą do wyników będzie spacy + cudowne dziecko . Spacy ma dobrze przemyślany model języka angielskiego, więc nie musisz tworzyć własnego. Prodigy pozwala szybko tworzyć zestawy danych treningowych i dostosowywać model spacy do swoich potrzeb.

Jeśli masz wystarczająco dużo próbek, możesz mieć przyzwoity model w 1 dzień.