12. 自然言語処理の基礎¶

words = ["Python", "は", "強力です"]
print("".join(words))
print(" ".join(words))

text = "Python is simple, powerful, and widely used."
print(text.split(","))
print(text.split())

text = "Pythonは楽しいです。"
print(text.replace("Python", "プログラミング"))

# テキストファイルの読み込み
with open("sample.txt", "r", encoding="utf-8") as f:
    text = f.read()

print(text[:100])  # 最初の100文字を表示

# 日本語テキストの例
japanese_text = "これは日本語のサンプルテキストです。機械学習を学びます。"

# 文字数
print(f"文字数: {len(japanese_text)}")

# 日本語の分割（単純なsplitでは不十分）
words = japanese_text.split()
print(f"split結果: {words}")  # スペースで区切られていないので1つの文字列

# 文字単位で処理
chars = list(japanese_text)
print(f"文字リスト（最初の10文字）: {chars[:10]}")

!pip install mecab-python3 unidic-lite

import MeCab

tagger = MeCab.Tagger()

import MeCab

# MeCab のインスタンス生成
tagger = MeCab.Tagger()

# 解析するテキスト
text = "すもももももももものうち"

# 形態素解析を実行し、結果を表示
result = tagger.parse(text)
print(result)

tagger = MeCab.Tagger("-Owakati")
result = tagger.parse("すもももももももものうち")
print(result)

tagger = MeCab.Tagger("-Oyomi")
result = tagger.parse("すもももももももものうち")
print(result)

node = tagger.parseToNode(text)

import MeCab

# MeCab のインスタンス生成
tagger = MeCab.Tagger()

# 解析するテキスト
text = "すもももももももものうち"

# 形態素解析を実行し、ノードに変換
node = tagger.parseToNode(text)

# 単語と品詞を格納するためのリスト
words = []
types = []

# ノードがなくなるまで解析結果を表示
while node:
    if node.surface:  # surface 属性（単語）が存在する場合
        words.append(node.surface)
        types.append(node.feature.split(",")[0])
    node = node.next  # 次のノードに移動

print("単語:", words)
print("品詞:", types)

import MeCab

# MeCab のインスタンス生成
tagger = MeCab.Tagger()

# 解析するテキスト
text = "すもももももももものうち"

# 形態素解析を実行し、ノードに変換
node = tagger.parseToNode(text)

# 単語を格納するためのリスト
nouns = []

# ノードがなくなるまで解析結果を表示
while node:
    pos = node.feature.split(",")[0]  # 品詞を取得
    if pos == "名詞":  # 品詞が「名詞」であった場合
        nouns.append(node.surface)
    node = node.next  # 次のノードに移動

print("名詞:", nouns)

text = "これは【重要】なお知らせです。詳細は★こちら★をご覧ください。"

# 不要な記号を削除
text = text.replace("【", "")
text = text.replace("】", "")
text = text.replace("★", "")

print(text)

import re

re.sub(パターン, 置換後の文字列, 対象の文字列)

import re

# 日本語テキストのサンプル
text = """
これは日本語のサンプルです。
メールアドレス: test@example.com
URL: https://example.jp
電話番号: 03-1234-5678
"""

print("元のテキスト:")
print(text)

# URL の削除
text = re.sub(r'https?://\S+', '', text)

# メールアドレスの削除
text = re.sub(r'\S+@\S+', '', text)

# 電話番号の削除（日本の形式）
text = re.sub(r'\d{2,4}-\d{2,4}-\d{4}', '', text)

# 余分な空白・改行の削除
text = re.sub(r'\s+', ' ', text).strip()

print("クリーニング後:")
print(text)

import MeCab

# 日本語のストップワード（例）
japanese_stop_words = ['は', 'を', 'が', 'に', 'で', 'と', 'の', 'も', 'や', 'など', 'て', 'た', 'だ', 'する', 'ある', 'いる']

# MeCab のインスタンス生成（分かち書き）
tagger = MeCab.Tagger("-Owakati")

text = "私は機械学習を勉強しています。"

# 形態素解析を実行
result = tagger.parse(text)
tokens = result.strip().split()
print(f"元の単語: {tokens}")

# ストップワード除去
filtered_tokens = [word for word in tokens if word not in japanese_stop_words]
print(f"フィルタ後: {filtered_tokens}")

import MeCab

tagger = MeCab.Tagger()
text = "私は機械学習を勉強しています。自然言語処理は面白いです。"

node = tagger.parseToNode(text)

# 名詞、動詞、形容詞のみを抽出
content_words = []
while node:
    pos = node.feature.split(",")[0]
    if pos in ["名詞", "動詞", "形容詞"]:
        content_words.append(node.surface)
    node = node.next

print("内容語:", content_words)

import re
import MeCab

# 日本語テキストの前処理パイプライン
def preprocess_japanese_text(text):
    # 1. URLの削除
    text = re.sub(r'https?://\S+', '', text)

    # 2. メールアドレスの削除
    text = re.sub(r'\S+@\S+', '', text)

    # 3. 余分な空白・改行の削除
    text = re.sub(r'\s+', '', text)

    # 4. 形態素解析
    tagger = MeCab.Tagger()
    node = tagger.parseToNode(text)

    tokens = []
    while node:
        # 品詞情報を取得
        features = node.feature.split(",")
        pos = features[0]  # 品詞
        surface = node.surface  # 表層形

        # 名詞、動詞、形容詞のみを抽出
        if pos in ['名詞', '動詞', '形容詞']:
            tokens.append(surface)

        node = node.next

    return tokens

# テスト
sample_text = """
私は機械学習を勉強しています。
自然言語処理は非常に面白いです。
詳細は https://example.jp をご覧ください。
"""

print("元のテキスト:")
print(sample_text)

processed_tokens = preprocess_japanese_text(sample_text)

print("前処理後の単語:")
print(processed_tokens)

print(f"\n単語数: {len(processed_tokens)}")

import MeCab

# テキストから名詞を抽出
def extract_nouns(text, tagger):
    node = tagger.parseToNode(text)
    nouns = []
    while node:
        pos = node.feature.split(",")[0]
        if pos == "名詞":
            nouns.append(node.surface)
        node = node.next
    return nouns

# 複数の文書
documents = [
    "吾輩は猫である。名前はまだ無い。",
    "どこで生れたかとんと見当がつかぬ。",
    "何でも薄暗いじめじめした所でニャーニャー泣いていた事だけは記憶している。"
]

# MeCab のインスタンス生成
tagger = MeCab.Tagger()

# 各文書から名詞を抽出
for i, doc in enumerate(documents, 1):
    nouns = extract_nouns(doc, tagger)
    print(f"文書{i}: {nouns}")

import MeCab
from sklearn.feature_extraction.text import CountVectorizer
import pandas as pd

# MeCab の初期化（分かち書きモード）
mecab = MeCab.Tagger("-Owakati")

# 日本語のサンプル文書
documents = [
    "私は機械学習が好きです",
    "私は機械学習も深層学習も好きです",
    "機械学習は楽しいです"
]

# 形態素解析を実行
tokenized_docs = []
for doc in documents:
    tokenized = mecab.parse(doc).strip()
    tokenized_docs.append(tokenized)

print("形態素解析後:")
for doc in tokenized_docs:
    print(f"  {doc}")

# CountVectorizerの初期化
vectorizer = CountVectorizer()

# BoWベクトルの作成
bow_matrix = vectorizer.fit_transform(tokenized_docs)

# 語彙の確認
vocab = vectorizer.get_feature_names_out()
print("\n語彙:")
print(vocab)

# ベクトルの確認（密行列に変換）
bow_array = bow_matrix.toarray()
print("\nBoW ベクトル:")
print(bow_array)

# DataFrame 表示
df = pd.DataFrame(bow_array, columns=vocab)
print("\nDataFrame 表示:")
print(df)

import MeCab
from sklearn.feature_extraction.text import CountVectorizer

# MeCab の初期化（分かち書きモード）
mecab = MeCab.Tagger("-Owakati")

# パラメータの例
vectorizer = CountVectorizer(
    max_features=100,      # 最大語彙数
    min_df=2,              # 最低文書頻度（2文書以上に出現）
    max_df=0.8,            # 最大文書頻度（80%以下の文書に出現）
    ngram_range=(1, 2)     # n-gram（単語と2単語の組み合わせ）
)

documents = [
    "私は機械学習が好きです",
    "私は機械学習も深層学習も好きです",
    "機械学習は楽しいです",
    "深層学習は面白いです"
]

# 形態素解析を実行
tokenized_docs = []
for doc in documents:
    tokenized = mecab.parse(doc).strip()
    tokenized_docs.append(tokenized)

bow_matrix = vectorizer.fit_transform(tokenized_docs)

print("語彙（n-gram含む）:")
print(vectorizer.get_feature_names_out())

print("\nBoW ベクトル:")
print(bow_matrix.toarray())

import MeCab
from sklearn.feature_extraction.text import CountVectorizer

# MeCab の初期化（分かち書きモード）
mecab = MeCab.Tagger("-Owakati")

documents = [
    "私は機械学習が好きです",
    "機械学習は楽しいです"
]

# 形態素解析を実行
tokenized_docs = []
for doc in documents:
    tokenized = mecab.parse(doc).strip()
    tokenized_docs.append(tokenized)

# Unigram（デフォルト）
vectorizer_1gram = CountVectorizer(ngram_range=(1, 1))
bow_1gram = vectorizer_1gram.fit_transform(tokenized_docs)

# Bigram
vectorizer_2gram = CountVectorizer(ngram_range=(2, 2))
bow_2gram = vectorizer_2gram.fit_transform(tokenized_docs)

# Unigram + Bigram
vectorizer_both = CountVectorizer(ngram_range=(1, 2))
bow_both = vectorizer_both.fit_transform(tokenized_docs)

print("Unigram:")
print(vectorizer_1gram.get_feature_names_out())

print("\nBigram:")
print(vectorizer_2gram.get_feature_names_out())

print("\nUnigram + Bigram:")
print(vectorizer_both.get_feature_names_out())

import numpy as np

# サンプル文書
documents = [
    "私は猫が好きです",
    "私は犬が好きです",
    "猫と犬は動物です"
]

# 単語 "私" の出現状況
# 文書1: 1回, 文書2: 1回, 文書3: 0回 → 3文書中2文書に出現

# 単語 "動物" の出現状況
# 文書1: 0回, 文書2: 0回, 文書3: 1回 → 3文書中1文書に出現

# IDF の計算
total_docs = 3
docs_with_watashi = 2
docs_with_animal = 1

idf_wa = np.log(total_docs / docs_with_watashi)
idf_animal = np.log(total_docs / docs_with_animal)

print(f"IDF('私'): {idf_wa:.4f}")
print(f"IDF('動物'): {idf_animal:.4f}")
print(f"\n'動物' の IDF は '私' の {idf_animal / idf_wa:.2f} 倍")

import MeCab
from sklearn.feature_extraction.text import TfidfVectorizer
import pandas as pd

# MeCab の初期化（分かち書きモード）
mecab = MeCab.Tagger("-Owakati")

# 日本語のサンプル文書
documents = [
    "私は機械学習が好きです",
    "私は機械学習も深層学習も好きです",
    "機械学習は楽しいです",
    "猫が窓辺に座っています"
]

# 形態素解析を実行
tokenized_docs = []
for doc in documents:
    tokenized = mecab.parse(doc).strip()
    tokenized_docs.append(tokenized)

# TF-IDF ベクトライザ
tfidf_vectorizer = TfidfVectorizer()
tfidf_matrix = tfidf_vectorizer.fit_transform(tokenized_docs)

# 語彙
vocab = tfidf_vectorizer.get_feature_names_out()
print("語彙:")
print(vocab)

# TF-IDF 行列
tfidf_array = tfidf_matrix.toarray()
print("\nTF-IDF ベクトル:")
print(tfidf_array)

# DataFrame 表示
df = pd.DataFrame(tfidf_array, columns=vocab)
print("\nDataFrame 表示:")
print(df.round(3))

# IDF 値の確認
print("\nIDF 値:")
idf_df = pd.DataFrame({
    '単語': vocab,
    'IDF': tfidf_vectorizer.idf_
}).sort_values('IDF', ascending=False)
print(idf_df)

import numpy as np
import MeCab
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

# サンプル文書コーパス
documents = [
    "機械学習はデータからパターンを学習する技術です",
    "深層学習はニューラルネットワークを用いた機械学習の手法です",
    "自然言語処理はテキストデータを分析する技術です",
    "画像認識は写真や動画から物体を検出する技術です",
    "機械学習を使ってテキストを分類することができます",
]

# MeCabで分かち書き
tagger = MeCab.Tagger("-Owakati")
wakati_docs = [tagger.parse(doc).strip() for doc in documents]

# TF-IDFベクトルの生成
vectorizer = TfidfVectorizer()
tfidf_matrix = vectorizer.fit_transform(wakati_docs)

# クエリに類似した文書を検索して順位付けする
def search_similar(query, documents, vectorizer, tfidf_matrix, top_n=3):
    # クエリをMeCabで分かち書き
    tagger = MeCab.Tagger("-Owakati")
    query_wakati = tagger.parse(query).strip()

    # クエリをTF-IDFベクトルに変換（学習済みのvectorizerを使用）
    query_vec = vectorizer.transform([query_wakati])

    # クエリとコーパス内の各文書とのコサイン類似度を計算
    similarities = cosine_similarity(query_vec, tfidf_matrix)[0]

    # 類似度の高い順にソート
    ranking = np.argsort(similarities)[::-1]

    print(f"クエリ: 「{query}」\n")
    print("類似文書ランキング:")
    for rank, idx in enumerate(ranking[:top_n], 1):
        print(f"  {rank}位 (類似度: {similarities[idx]:.4f}): {documents[idx]}")

# 検索の実行
query = "テキストデータの分析と分類の方法"
search_similar(query, documents, vectorizer, tfidf_matrix)