Jak mogę zbudować model, aby odróżnić Tweety o Apple (Inc.) z tweetów o jabłku (owocu)?

To, czego szukasz, nazywa się nazwanym rozpoznawaniem encji . Jest to technika statystyczna, która (najczęściej) używa warunkowych pól losowych do znajdowania nazwanych jednostek, w oparciu o wyszkolenie do uczenia się rzeczy o nazwanych jednostkach.

Zasadniczo, to patrzy na treść ikontekst słowa, (Patrząc wstecz i do przodu kilka słów), aby oszacować prawdopodobieństwo, że słowo jest nazwany podmiot.

Dobre oprogramowanie potrafi spojrzeć na inne funkcje "Vcv", jeśli zaczyna się od "samogłoska-spółgłoska-samogłoska")

Bardzo dobrą biblioteką (GPL) jest Stanford ' s NER

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

Jakiś przykładowy tekst do wypróbowania:

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

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

Mam pół-działający system, który rozwiązuje ten problem, open source przy użyciu scikit-learn, z serią postów na blogu opisujących to, co robię. Problem, z którym się zmagam, to disambiguation (wybór jednej z wielu opcji word sense), co nie jest tym samym, co nazwane Rozpoznawanie Bytów. Moje podstawowe podejście jest nieco konkurencyjne w stosunku do istniejących rozwiązań i (co najważniejsze) można je dostosować.

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

Niektóre z nich wykorzystałem do projektu klienta( konsultuję przy użyciu NLP/ML w Londynie), ale nie byłem zadowolony z ich recall (precision i recall). Zasadniczo mogą być precyzyjne( kiedy mówią" To jest Apple Inc", zazwyczaj są poprawne), ale z niskim przypomnieniem (rzadko mówią "To jest Apple Inc", chociaż dla człowieka tweet jest oczywiście o Apple Inc). Pomyślałem, że to będzie ciekawe intelektualnie ćwiczenie polegające na zbudowaniu wersji open source dostosowanej do tweetów. Oto aktualny kod: https://github.com/ianozsvald/social_media_brand_disambiguator

Zwrócę uwagę - nie staram się rozwiązywać ogólnego problemu disambiguacji z tym podejściem, tylko Marka disambiguacja (firmy, ludzie itp.), kiedy już znasz ich imię. Dlatego uważam, że takie proste podejście zadziała.

I started this six kilka tygodni temu, i jest napisany w Pythonie 2.7 przy użyciu scikit-learn. Wykorzystuje bardzo podstawowe podejście. Wektoryzuję używając binarnego wektoryzatora count (liczę tylko czy słowo się pojawi, a nie ile razy) z 1-3 n-gram. Nie skaluję z TF-IDF (TF-IDF jest dobry, gdy masz zmienną długość dokumentu; dla mnie tweety są tylko jednym lub dwoma zdaniami, a moje wyniki testów nie wykazały poprawy z TF-IDF).

Używam podstawowego tokenizera, który jest bardzo podstawowy, ale zaskakująco przydatne. Ignoruje @ # (więc tracisz jakiś kontekst) i oczywiście nie rozszerza adresu URL. Następnie trenuję używając regresji logistycznej i wydaje się, że ten problem jest nieco liniowo rozdzielny (wiele terminów dla jednej klasy nie istnieje dla drugiej). Obecnie unikam wszelkich stemming/czyszczenie(staram się najprostszą możliwą rzeczą, która może działać).

Kod ma pełny README, powinieneś być w stanie stosunkowo łatwo przyswoić swoje tweety, a następnie podążać za moimi sugestiami dotyczącymi testuję.

To działa na 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ą kategorię lub drugą. Ten warunek może się nie utrzymać, 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, rewizji egzaminu i zespołu muzycznego). Tutaj może być wymagane sprytniejsze podejście.

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

Jeśli używasz czegoś takiego jak LogisticRegression (gdzie masz prawdopodobieństwo dla każdej klasyfikacji), możesz wybrać tylko pewne klasyfikacje, a w ten sposób możesz wymusić wysoką precyzję, handlując przeciwko wycofaniu (więc uzyskasz poprawne wyniki, ale mniej z nich). Będziesz musiał dostroić to do swojego system.

Oto możliwe podejście algorytmiczne przy użyciu scikit-learn:

• użyj binarnego CountVectorizer (nie sądzę, termin-liczy się w krótkich wiadomościach dodać wiele informacji, ponieważ większość słów występuje tylko raz)
• zacznij od klasyfikatora drzewa decyzyjnego. Będzie miał możliwą do wytłumaczenia Wydajność (zobacz Overfitting with a Decision Tree na przykład).
• przejdź do regresji logistycznej
• zbadaj błędy generowane przez klasyfikatory (Czytaj wyeksportowane wyjście DecisionTree lub spójrz na współczynniki w LogisticRegression, pracuj nad źle sklasyfikowanymi tweetami przez Wektoryzator, aby zobaczyć, jak wygląda podstawowa reprezentacja worka słów - 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 dla pracującej wersji tego podejście

Rzeczy do rozważenia:

Potrzebujesz większego zbioru danych. Na przykład, jeśli chcesz mieć więcej niż 2000 postów, to musisz mieć co najmniej 100 na klasę (zobacz poniższą notkę).]} W przeciwieństwie do innych programów, które nie są dostępne na rynku, nie są dostępne na rynku i nie są dostępne na rynku.]}
• rozważ klasyfikator nieliniowy (jak sugestia @oiez powyżej), gdy rzeczy się mocniej. Osobiście uważam, że LinearSVC wypada gorzej niż regresja logistyczna (ale może to być spowodowane wysokimi wymiarami przestrzeni cech, które jeszcze nie zmniejszyłem).
W 1999 roku, w ramach projektu, w ramach projektu, stworzonego w ramach projektu, stworzono nową platformę, w której użytkownicy będą mogli korzystać ze wszystkich funkcji, takich jak np.]}
• gdy będziesz miał dużo żetonów, prawdopodobnie będziesz chciał dokonać redukcji wymiarów (jeszcze tego nie próbowałem-zobacz mój wpis na blogu LogisticRegression l1 l2 penalizacja)

Re. zbytnio. W moim zbiorze danych z 2000 pozycji mam 10 minutową migawkę z Twittera "apple" tweetów. Około 2/3 tweetów jest dla Apple Inc, 1/3 dla innych-Apple-zastosowań. Wyciągam zrównoważony podzbiór (myślę o 584 rzędach) każdej klasy i robię pięciokrotną walidację krzyżową do treningu.

Ponieważ mam tylko 10 minutowe okno czasowe, mam wiele tweetów na ten sam temat i prawdopodobnie dlatego mój klasyfikator tak dobrze radzi sobie z istniejącymi narzędziami - będzie on nadmiernie dostosowywał się do funkcji szkoleniowych, nie uogólniając dobrze (podczas gdy istniejące narzędzia komercyjne działają gorzej na tym snapshopie, ale bardziej niezawodnie w szerszym zestawie danych). Będę rozszerzać moje okno czasowe, aby przetestować to jako kolejny kawałek pracy.

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

1. Stwórz dict słów zawierających ich liczbę wystąpień w tweetach związanych z owocami i firmą. Można to osiągnąć, podając mu kilka przykładowych tweetów, których skłonność znamy.

2. Korzystając z wystarczającej ilości wcześniejszych danych, możemy dowiedzieć się, prawdopodobieństwo wystąpienia słowa w tweecie o apple inc.

3. Pomnóż prawdopodobieństwo poszczególnych słów, aby uzyskać prawdopodobieństwo całego tweeta.

Uproszczony przykład:

P_f =

P_w_f = prawdopodobieństwo wystąpienia słowa w owocach.

P_t_f = połączone prawdopodobieństwo wystąpienia wszystkich słów w tweecie = p_w1_f * p_w2_f*...

P_f_t =

P_c, p_w_c, p_t_c, p_c_t są odpowiednimi wartościami dla firmy.

Dodaje się płynność laplacian o wartości 1 do wyeliminuj 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 mógłbyś sam kodować. Zrobiłbym coś takiego:

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 kończysz z dwiema listami, które wyglądają tak:

([['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])

The [1, 1, 0, 0] reprezentują pozytywne i negatywne etykiety.

Następnie tworzysz rurociąg! Pipeline jest klasą scikit-learn, która ułatwia łączenie etapów przetwarzania tekstu ze sobą, więc musisz wywołać tylko jeden obiekt podczas treningu/przewidywania: {]}

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 rurociągu 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 go usunąć w zależności na ocenę dokładności (robienie testów walidacji krzyżowej i szukanie najlepszych parametrów w siatce jest trochę zaangażowane, więc nie będę się w to tutaj). LinearSVC jest standardowym algorytmem klasyfikacji tekstu.

Wreszcie, przewidujesz kategorię tweetów:

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

Ponownie, tweet musi być na liście, więc założyłem, że wpisuje funkcję jako ciąg znaków.

I nie testował tego kodu, więc może nie działać, jeśli po prostu kopiuj-wklej, ale jeśli chcesz użyć scikit-dowiedz się, powinien dać ci pomysł, od czego zacząć.

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

Używanie drzewa decyzyjnego wydaje się działać całkiem dobrze dla tego problemu. Przynajmniej daje większą dokładność niż naiwny klasyfikator Bayesa z moimi wybranymi cechami.

Jeśli chcesz się pobawić kilkoma możliwościami, możesz użyć poniższego kodu, który wymaga zainstalowania nltk. Książka nltk jest również dostępna bezpłatnie w Internecie, więc może zechcesz przeczytać trochę o tym, jak to wszystko naprawdę 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 rozwiązanie robocze , które przygotowałem za pomocą 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 wyjścia:

           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 przykładach, które podałeś, Apple (inc) było określane jako A pple lub apple inc , więc możliwym sposobem może być szukanie:

• Duże " A " w Apple

• "inc" po apple

• Słowa / frazy takie jak "OS", "SYSTEM OPERACYJNY", "Mac", "iPhone",...

• Lub ich kombinacji

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ę vs jabłko owoc. Pozwól, że przedstawię tutaj listę funkcji, które mogą być przydatne na początek. Aby uzyskać więcej informacji, poszukaj rzeczownika fraza chunking i coś o nazwie BIO etykiety. Zobacz ( http://www.cis.upenn.edu/ ~ pereira / papers / crf. pdf )

Otaczające słowa: Zbuduj wektor funkcji dla poprzedniego słowa i następne słowo, lub jeśli chcesz więcej funkcji być może poprzednie 2 i następne 2 słowa. Nie chcesz zbyt wiele słów w modelu lub nie będzie pasować do danych bardzo dobrze. W przetwarzaniu języka naturalnego, będziesz chciał zachować to tak ogólne, Jak to możliwe.

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

Czy pierwszy znak jest wielką

Czy ostatni znak w słowie jest kropką

Część mowy słowa (Sprawdź część tagowania mowy)

Sam tekst słowa

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

WordIs (Apple)

NextWordIs (Inc.)

Rozumiesz. Pomyśl o rozpoznawaniu nazw jako opisaniu sekwencji, a następnie użyj matematyki, aby powiedzieć komputerowi, jak to obliczyć.

Należy pamiętać, że przetwarzanie języka naturalnego jest systemem opartym na potoku. Zazwyczaj włamujesz się do zdania, przejdź do tokenizacji, a następnie część tagowania mowy lub 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.

Istnieje naprawdę dobra biblioteka do przetwarzania tekstu w języku naturalnym w Python o nazwie nltk. Powinieneś na to spojrzeć.

Jedną ze strategii, którą możesz spróbować, jest spojrzenie na n-gram (grupy słów) ze słowem "apple" w nich. Niektóre słowa są bardziej prawdopodobne, aby być używane obok "apple", gdy mówimy o owocu, inne, gdy mówimy o firmie, i można ich użyć do klasyfikacji tweetów.

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

I pochodzi od twórców LIBSVM i LIBLINEAR, których wektor wsparcia implementacja machine (SVM) jest używana w sklearn i cran, więc możesz mieć pewność, że ich implementacja nie jest błędna.

Zrób filtr AI, aby odróżnić Apple Inc (firma) od apple (owoc). Ponieważ są to tweety, zdefiniuj swój zestaw treningowy za pomocą wektora 140 pól, z których każde pole jest znakiem zapisanym w tweecie na pozycji X (od 0 do 139). Jeśli tweet jest krótszy, po prostu podaj wartość za bycie pustym.

Następnie zbuduj zestaw treningowy wystarczająco duży, aby uzyskać dobrą dokładność (subiektywną do Twojego gustu). Przypisz wartość wyniku do każdego tweeta, a Apple Inc tweet get 1 (true) a jabłko (fruit) dostaje 0. Byłby to przypadek nadzorowanego uczenia się {[10] } w regresji logistycznej.

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

Nie wiem Python , więc nie mogę napisać do niego kodu, ale gdybyś miał poświęcić więcej czasu na logikę i teorię uczenia maszynowego, mógłbyś poszukać klasy, której jestem podążam.

Wypróbuj kurs Coursera Uczenie maszynowe By Andrew Ng . Nauczysz się uczenia maszynowego na MATLAB lub Octave , ale gdy zdobędziesz podstawy, będziesz w stanie napisać uczenie maszynowe w dowolnym języku, jeśli rozumiesz prostą matematykę (prostą w regresji logistycznej).

Oznacza to, że uzyskanie kodu od kogoś nie sprawi, że będziesz w stanie zrozumieć, co dzieje się w kodzie uczenia maszynowego. Ty warto zainwestować kilka godzin w ten temat, aby zobaczyć, co naprawdę się dzieje.