[PYTHON] Essayez de classer les livres d'O'Reilly en les regroupant

Cible

Obtenez les informations sur le livre sur le site Web O'Reilly Japon, Classons les livres par regroupement non hiérarchique à partir des informations acquises. La procédure est la suivante. ・ Accédez aux informations détaillées du livre à partir de la première page du Web Obtenez le texte de cette introduction dans une liste ・ Pour chaque livre, les phrases de cette introduction sont décomposées en niveaux de mots et chaque mot est pondéré. ・ Sur la base des informations ci-dessus, classez les livres en les regroupant Le langage utilise Python.

Obtenir des informations sur le Web

• Je pense que diverses informations sortiront si vous vérifiez en explorant et en grattant.

1. Tout d'abord, obtenez toutes les URL de la page de détails du nouveau livre sur la première page, Stocker sous forme de tableau dans allBookLinks.

clustering.py

#coding:utf-8

import numpy as np
import mechanize
import MeCab
import util
import re
from bs4 import BeautifulSoup
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.cluster import KMeans
from sklearn.cluster import AffinityPropagation

# get O'Reilly new books from Top page
page = mechanize.Browser()
page.open('http://www.oreilly.co.jp/index.shtml')

response = page.response()
soup = BeautifulSoup(response.read(), "html.parser")

allBookLinks = []
bibloLinks = soup.find_all("p", class_="biblio_link")
for bibloLink in bibloLinks:
    books = bibloLink.find_all("a", href=re.compile("http://www.oreilly.co.jp/books/"))
    for book in books:
        allBookLinks.append( book.get("href") )

2. Accédez à l'URL de la page de détail du livre obtenu ci-dessus et depuis la page de destination Stockez le titre du livre dans titleList et le texte d'introduction dans inputDatas. Obtenez également l'URL des informations relatives au livre et n'ajoutez qu'un seul niveau à la liste.

clustering.py

def get_detail_sentence_list( detailPageLink ):
    page.open( detailPageLink )
    detailResponse = page.response()
    detailSoup = BeautifulSoup( detailResponse.read(), "html.parser" )
    # get title
    titleTag = detailSoup.find("h3", class_="title")
    title = titleTag.get_text().encode('utf-8')
    # get detail
    detailDiv = detailSoup.find("div", id="detail")
    detail = detailDiv.find("p").get_text().encode('utf-8')
    # get relation book links
    relationLinks = detailDiv.find_all("a")
    relationLinkList = []
    for relationLink in relationLinks:
        href = relationLink.get("href")
        if href.find('/books/') > 0:
            relationLinkList.append(href[href.find('/books/') + len('/books/'):])
    return [ title, detail, relationLinkList ]


# crolling books info
titleList = []
inputDatas = []
for bookLink in allBookLinks:
    title, detail, relationLinkList = get_detail_sentence_list( bookLink )
    # save
    if not (title in titleList):
        titleList.append(title)
        inputDatas.append( detail )

    # go to relation book links
    for relationLink in relationLinkList:
        title, detail, relationLinkList = get_detail_sentence_list( 'http://www.oreilly.co.jp/books/' + relationLink )
        # save
        if not (title in titleList):
            titleList.append(title)
            inputDatas.append( detail )

Pondérer le texte d'introduction de chaque livre en utilisant la méthode TF-IDF

Le contenu de X utilisant TfidfVectorizer est ・ Len (X) = nombre de livres recherchés ・ Len (X [0]) = nombre de mots dans le texte d'introduction du livre ・ X [0] [0] = 0 Valeur TF-IDF du 0ème mot (mot stocké dans les termes [0]) dans le 0ème livre Une procession comme ça. Vous pouvez calculer TF-IDF en créant une logique, mais il est plus facile d'utiliser cette bibliothèque.

clustering.py

def get_word_list( targetText ):
    tagger = MeCab.Tagger()
    wordList = []
    if len(targetText) > 0:
        node = tagger.parseToNode(targetText)
        while node:
            if len(util.mytrim(node.surface)) > 0:
                wordList.append(node.surface)
            node = node.next
    return wordList

tfidfVectonizer = TfidfVectorizer(analyzer=get_word_list, min_df=1, max_df=50)
X = tfidfVectonizer.fit_transform( inputDatas )
terms = tfidfVectonizer.get_feature_names()

util.py

#coding:utf-8

def mytrim( target ):
    target = target.replace('　','')
    return target.strip()

Classer les livres par regroupement

Je l'ai essayé à la fois avec K-means et Affinity Propagation. K-means est utilisé lorsqu'il est décidé du nombre de pièces à classer en premier, Si vous n'avez pas décidé, la propagation d'affinité fonctionne plutôt bien. Je pense que la propagation d'affinité était plus appropriée dans ce cas.

clustering.py

# clustering by KMeans
k_means = KMeans(n_clusters=5, init='k-means++', n_init=5, verbose=True)
k_means.fit(X)
label = k_means.labels_

clusterList = {}
for i in range(len(titleList)):
    clusterList.setdefault( label[i], '' )
    clusterList[label[i]] = clusterList[label[i]] + ',' + titleList[i]

print 'By KMeans'
for key, value in clusterList.items():
    print key
    print value

print 'By AffinityPropagation'
# clustering by AffinityPropagation
af = AffinityPropagation().fit(X)
afLabel = af.labels_
afClusterList = {}
for i in range(len(titleList)):
    afClusterList.setdefault( afLabel[i], '' )
    afClusterList[afLabel[i]] = afClusterList[afLabel[i]] + ',' + titleList[i]

for key, value in afClusterList.items():
    print key
    print value

Ichiou, le résultat de l'exécution de celui utilisant la propagation d'affinité

Ça ressemble à ça!

Classification 1

Système d'apprentissage automatique pratique

Python hautes performances

Première informatique

Make: Electronics - Bases des circuits électriques et électroniques que vous pouvez faire et comprendre

Planification des capacités - Analyse du site / Prévisions / Placement pour tirer le meilleur parti des ressources

Détails Ethernet 2e édition

Introduction à la visualisation de données avec JavaScript

Classification 2

Pratiquez Python 3

Cython - Accélérer Python en fusionnant avec C

MongoDB & Python

Livre de recettes Python et AWS

Introduction à l'analyse de données avec Python-Traitement des données avec NumPy et pandas

Explication détaillée de la grammaire Python

Vision par ordinateur pratique

Introduction à Python 3

Première 3e édition de Python

Tutoriel Python 2e édition

Premiers pas avec Arduino 3e édition

Commençons par le traitement

Python Cookbook 2nd Edition

Introduction au traitement du langage naturel

OpenStack Swift-Management et développement du stockage d'objets Swift

Gestion du réseau de stockage SAN et NAS

Classification 3

Recette pratique de prototypage Lab-Arduino pour «penser tout en faisant»

Fonctionnement Web - Technique pratique de gestion des opérations de site

Évaluation pratique de la vulnérabilité Metasploit par test de pénétration

Visualisation de la méthode de visualisation des données-informations par traitement

Belle visualisation

Classification 4

Métaprogrammation Ruby 2e édition

Meilleures pratiques Ruby - Code et techniques professionnels

Comprendre le calcul - Des machines simples aux programmes impossibles

Première fois Ruby

Langage de programmation Ruby

Classification 5

Modèles de conception Selenium et bonnes pratiques

Pratiquez Selenium WebDriver

JavaScript testable

Beaux tests - Belle pratique de tests logiciels