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

  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.

スクリーンショット 2015-12-05 20.54.17.png

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") )

  1. 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.

スクリーンショット 2015-12-05 21.09.01.png

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

Recommended Posts

Essayez de classer les livres d'O'Reilly en les regroupant
[Python] Essayez de classer les boutiques de ramen par traitement du langage naturel
Essayez de faire face à la somme partielle
Livres recommandés par 3 types liés à Python
Essayez de prédire la demande de puissance par l'apprentissage automatique
J'ai essayé de classer les boules de dragon par adaline
[Keras] Mémo personnel pour classer les images par dossier [Python]
Expérience de clustering par échantillonnage
Essayez de refactoriser tout en prenant des mesures
[Réunion de changement d'emploi] Essayez de classer les entreprises en traitant le bouche-à-oreille en langage naturel avec word2vec
[En gros] Clustering par K Means
Essayez d'implémenter yolact
J'ai essayé de classer MNIST par GNN (avec PyTorch géométrique)