6.1. Oczyszczanie tekstu

# Utworzenie tekstu.
text_data = ["   Wykrzyknik i znak zapytania, autor Aishwarya Henriette     ",
             "Techniki parkowania, autor Karl Gautier",
             "    Dzisiaj jest ta noc, autor Jarek Prakash   "]

# Usunięcie białych znaków.
strip_whitespace = [string.strip() for string in text_data]

# Wyświetlenie tekstu.
strip_whitespace

['Wykrzyknik i znak zapytania, autor Aishwarya Henriette',
 'Techniki parkowania, autor Karl Gautier',
 'Dzisiaj jest ta noc, autor Jarek Prakash']

# Usunięcie słowa „autor”.
remove_periods = [string.replace("autor", "") for string in strip_whitespace]

# Wyświetlenie tekstu.
remove_periods

['Wykrzyknik i znak zapytania, Aishwarya Henriette',
 'Techniki parkowania, Karl Gautier',
 'Dzisiaj jest ta noc, Jarek Prakash']





# Utworzenie funkcji.
def capitalizer(string: str) -> str:
    return string.upper()

# Wywołanie funkcji.
[capitalizer(string) for string in remove_periods]

['WYKRZYKNIK I ZNAK ZAPYTANIA, AISHWARYA HENRIETTE',
 'TECHNIKI PARKOWANIA, KARL GAUTIER',
 'DZISIAJ JEST TA NOC, JAREK PRAKASH']





# Wczytanie biblioteki.
import re

# Utworzenie funkcji.
def replace_letters_with_X(string: str) -> str:
    return re.sub(r"[a-zA-Z]", "X", string)

# Wywołanie funkcji.
[replace_letters_with_X(string) for string in remove_periods]

['XXXXXXXXXX X XXXX XXXXXXXXX, XXXXXXXXX XXXXXXXXX',
 'XXXXXXXX XXXXXXXXXX, XXXX XXXXXXX',
 'XXXXXXX XXXX XX XXX, XXXXX XXXXXXX']





# Zdefiniowanie ciągu tekstowego.
s = "machine learning in python cookbook"

# Odszukanie indeksu pierwszego wystąpienia litery „n”.
find_n = s.find("n")

# Ustalenie, czy ciąg tekstowy rozpoczyna się od litery „m”.
starts_with_m = s.startswith("m")

# Ustalenie, czy ciąg tekstowy kończy się słowem „python”.
ends_with_python = s.endswith("python")

# Ustalenie, czy ciąg tekstowy jest alfanumeryczny.
is_alnum = s.isalnum()

# Ustalenie, czy ciąg tekstowy składa się jedynie ze znaków alfanumerycznych (nie zawiera spacji).
is_alpha = s.isalpha()

# Określenie kodowania ciągu tekstowego jako utf-8.
encode_as_utf8 = s.encode("utf-8")

# Dekodowanie ciągu tekstowego zakodowanego jako utf-8.
decode = encode_as_utf8.decode("utf-8")

print(
  find_n,
  starts_with_m,
  ends_with_python,
  is_alnum,
  is_alpha,
  encode_as_utf8,
  decode,
  sep = "|"
)

5|True|False|False|False|b'machine learning in python cookbook'|machine learning
  in python cookbook





6.2. Przetwarzanie i oczyszczanie danych HTML

# Wczytanie biblioteki.
from bs4 import BeautifulSoup

# Utworzenie przykładowego kodu HTML
html = "<div class='full_name'>"\
       "<span style='font-weight:bold'>Masego"\
       "</span> Azra</div>"

# Przetworzenie kodu HTML.
soup = BeautifulSoup(html, "lxml")

# Odszukanie znacznika div wraz z klasą "full_name" i wyświetlenie tekstu.
soup.find("div", { "class" : "full_name" }).text

'Masego Azra'





6.3. Usuwanie znaku przestankowego

# Wczytanie bibliotek.
import unicodedata
import sys

# Utworzenie tekstu.
text_data = ['Cześć!!!! Po. Prostu. Kocham. Tę. Piosenkę...',
             'Zgadzam się w 10000%!!!! #KochamTO',
             'Racja?!?!']

# Utworzenie słownika znaków przestankowych.
punctuation = dict.fromkeys(
  (i for i in range(sys.maxunicode)
  if unicodedata.category(chr(i)).startswith('P')
  ),
  None
)

# We wszystkich ciągach tekstowych mają zostać usunięte znaki przestankowe.
[string.translate(punctuation) for string in text_data]

['Cześć Po Prostu Kocham Tę Piosenkę', 'Zgadzam się w 10000 KochamTO', 'Racja']





6.4. Tokenizacja tekstu

# Wczytanie biblioteki.
from nltk.tokenize import word_tokenize

# Utworzenie tekstu.
string = "The science of today is the technology of tomorrow"

# Tokenizacja słów.
word_tokenize(string)

['The', 'science', 'of', 'today', 'is', 'the', 'technology', 'of', 'tomorrow']





# Wczytanie biblioteki.
from nltk.tokenize import sent_tokenize

# Utworzenie tekstu.
string = "The science of today is the technology of tomorrow. Tomorrow is today."

# Tokenizacja zdań.
sent_tokenize(string)

['The science of today is the technology of tomorrow.', 'Tomorrow is today.']





6.5. Usuwanie słów o małym znaczeniu

# Wczytanie biblioteki.
from nltk.corpus import stopwords

# Po pierwszym zaimportowaniu pakietu NLTK
# konieczne jest pobranie listy słów o małym znaczeniu.
# nltk.download('stopwords')

# Utworzenie tokenów słów.
tokenized_words = ['i',
                   'am',
                   'going',
                   'to',
                   'go',
                   'to',
                   'the',
                   'store',
                   'and',
                   'park']

# Wczytanie listy słów o małym znaczeniu.
stop_words = stopwords.words('english')

# Usunięcie słów o małym znaczeniu.
[word for word in tokenized_words if word not in stop_words]

['going', 'go', 'store', 'park']





# Wyświetlenie słów o małym znaczeniu.
stop_words[:5]

['i', 'me', 'my', 'myself', 'we']





6.6. Stemming słów

# Wczytanie biblioteki.
from nltk.stem.porter import PorterStemmer

# Utworzenie tokenów słów.
tokenized_words = ['i', 'am', 'humbled', 'by', 'this', 'traditional', 'meeting']

# Utworzenie egzemplarza klasy PorterStemmer.
porter = PorterStemmer()

# Użycie przygotowanego obiektu porter.
[porter.stem(word) for word in tokenized_words]

['i', 'am', 'humbl', 'by', 'thi', 'tradit', 'meet']





6.7. Oznaczanie części mowy

# Wczytanie bibliotek.
from nltk import pos_tag
from nltk import word_tokenize

# Utworzenie tekstu.
text_data = "Chris loved outdoor running"

# Użycie wstępnie wytrenowanego algorytmu.
text_tagged = pos_tag(word_tokenize(text_data))

# Wyświetlenie części mowy.
text_tagged

[('Chris', 'NNP'), ('loved', 'VBD'), ('outdoor', 'RP'), ('running', 'VBG')]





# Filtrowanie słów.
[word for word, tag in text_tagged if tag in ['NN','NNS','NNP','NNPS'] ]

['Chris']





# Wczytanie bibliotek.
from sklearn.preprocessing import MultiLabelBinarizer

# Utworzenie tekstu.
tweets = ["I am eating a burrito for breakfast",
          "Political science is an amazing field",
          "San Francisco is an awesome city"]

# Utworzenie listy.
tagged_tweets = []

# Oznaczenie każdego słowa i wiadomości w serwisie Twitter.
for tweet in tweets:
    tweet_tag = nltk.pos_tag(word_tokenize(tweet))
    tagged_tweets.append([tag for word, tag in tweet_tag])

# Użycie kodowania „gorącojedynkowego” do konwersji tagów na cechy.
one_hot_multi = MultiLabelBinarizer()
one_hot_multi.fit_transform(tagged_tweets)

array([[1, 1, 0, 1, 0, 1, 1, 1, 0],
       [1, 0, 1, 1, 0, 0, 0, 0, 1],
       [1, 0, 1, 1, 1, 0, 0, 0, 1]])





# Wyświetlenie nazw cech.
one_hot_multi.classes_

array(['DT', 'IN', 'JJ', 'NN', 'NNP', 'PRP', 'VBG', 'VBP', 'VBZ'], dtype=object)





6.8. Rozpoznawanie nazwanych jednostek

# Wczytanie biblioteki.
import spacy

# Wczytanie pakietu spaCy i użycie go do przetworzenia tekstu.
# Należy się upewnić o wykonaniu polecenia "python -m spacy download en".
nlp = spacy.load("en_core_web_sm")
doc = nlp("Elon Musk offered to buy Twitter using $21B of his own money.")

# Wyświetlenie poszczególnych encji.
print(doc.ents)

# Dla każdej encji będą wyświetlone tekst i etykieta encji.
for entity in doc.ents:
    print(entity.text, entity.label_, sep=",")

(Elon Musk, Twitter, 21B)
Elon Musk, PERSON
Twitter, ORG
21B, MONEY





6.9. Kodowanie tekstu za pomocą modelu worka słów

# Wczytanie biblioteki.
import numpy as np
from sklearn.feature_extraction.text import CountVectorizer

# Utworzenie tekstu.
text_data = np.array(['I love Brazil. Brazil!',
                      'Sweden is best',
                      'Germany beats both'])

# Utworzenie macierzy cech zbioru słów.
count = CountVectorizer()
bag_of_words = count.fit_transform(text_data)

# Wyświetlenie macierzy cech.
bag_of_words

<3x8 sparse matrix of type '<class 'numpy.int64'>'
    with 8 stored elements in Compressed Sparse Row format>





bag_of_words.toarray()

array([[0, 0, 0, 2, 0, 0, 1, 0],
       [0, 1, 0, 0, 0, 1, 0, 1],
       [1, 0, 1, 0, 1, 0, 0, 0]], dtype=int64)





# Wyświetlenie nazw cech.
count.get_feature_names()

array(['beats', 'best', 'both', 'brazil', 'germany', 'is', 'love', 'sweden'], dtype=object)





# Utworzenie macierzy cech wraz z argumentami.
count_2gram = CountVectorizer(ngram_range=(1,2),
                              stop_words="english",
                              vocabulary=['brazil'])
bag = count_2gram.fit_transform(text_data)

# Wyświetlenie macierzy cech.
bag.toarray()

array([[2],
       [0],
       [0]])

# Wyświetlenie 1-gram i 2-gram.
count_2gram.vocabulary_

{'brazil': 0}





6.10. Określanie wagi słów

# Wczytanie bibliotek.
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer

# Utworzenie tekstu.
text_data = np.array(['I love Brazil. Brazil!',
                      'Sweden is best',
                      'Germany beats both'])

# Utworzenie macierzy cech do użycia z tf-idf.
tfidf = TfidfVectorizer()
feature_matrix = tfidf.fit_transform(text_data)

# Wyświetlenie macierzy cech tf-idf.
feature_matrix

<3x8 sparse matrix of type '<class 'numpy.float64'>'
    with 8 stored elements in Compressed Sparse Row format>





# Wyświetlenie macierzy cech tf-idf jako macierzy gęstej.
feature_matrix.toarray()

array([[ 0.        ,  0.        ,  0.        ,  0.89442719,  0.        ,
         0.        ,  0.4472136 ,  0.        ],
       [ 0.        ,  0.57735027,  0.        ,  0.        ,  0.        ,
         0.57735027,  0.        ,  0.57735027],
       [ 0.57735027,  0.        ,  0.57735027,  0.        ,  0.57735027,
         0.        ,  0.        ,  0.        ]])





# Wyświetlenie nazw cech.
tfidf.vocabulary_

{'beats': 0,
 'best': 1,
 'both': 2,
 'brazil': 3,
 'germany': 4,
 'is': 5,
 'love': 6,
 'sweden': 7}





6.11. Używanie wektorów tekstu do obliczania podobieństwa tekstu w zapytaniu wyszukiwania

# Wczytanie bibliotek.
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import linear_kernel

# Utworzenie możliwych do przeszukiwania danych tekstowych.
text_data = np.array(['I love Brazil. Brazil!',
                      'Sweden is best',
                      'Germany beats both'])

# Utworzenie macierzy cech do użycia z tf-idf.
tfidf = TfidfVectorizer()
feature_matrix = tfidf.fit_transform(text_data)

# Utworzenie zapytania wyszukiwania i jego przekształcenie na wektor tf-idf.
text = "Brazil is the best"
vector = tfidf.transform([text])

# Obliczenie cosinusa podobieństwa między wektorem danych wejściowych i wszystkimi pozostałymi wektorami.
cosine_similarities = linear_kernel(vector, feature_matrix).flatten()

# Pobranie indeksu najbardziej odpowiednich pozycji w kolejności.
related_doc_indicies = cosine_similarities.argsort()[:-10:-1]

# Wyświetlenie danych tekstowych najbardziej podobnych do zapytania wyszukiwania, razem z cosinusem podobieństwa.
print([(text_data[i], cosine_similarities[i]) for i in related_doc_indicies])
[
  (
    'Sweden is best', 0.6666666666666666),
    ('I love Brazil. Brazil!', 0.5163977794943222),
    ('Germany beats both', 0.0
    )
]





6.12. Używanie klasyfikatora analizy sentymentu

# Wczytanie biblioteki.
from transformers import pipeline

# Utworzenie potoku NLP odpowiedzialnego za przeprowadzenie analizy sentymentu.
classifier = pipeline("sentiment-analysis")

# Klasyfikacja danego tekstu.
# (Pierwsze uruchomienie może wymagać pobrania pewnych danych i modeli).
sentiment_1 = classifier("I hate machine learning! It's the absolute worst.")
sentiment_2 = classifier(
    "Machine learning is the absolute"
    "bees knees I love it so much!"
)

# Wyświetlenie danych wyjściowych analizy.
print(sentiment_1, sentiment_2)
[
  {
    'label': 'NEGATIVE',
    'score': 0.9998020529747009
  }
]
[
  {
    'label': 'POSITIVE',
    'score': 0.9990628957748413
  }
]
