Résumé de l'exploration d'image effectuée à la vitesse d'une seconde

Aperçu

Je pense que Kaggle est un ensemble de données à grande échelle, mais parfois vous n'avez pas l'image que vous recherchez.

En exécutant le code écrit dans cet article Exploration d'images,

Vous pouvez le faire facilement et rapidement. Ceci est un bref résumé de l'article de Kita et de l'exemple d'icrawler.

Édition Google

https://qiita.com/Yuki-Takatsu/items/3f30727d5b21a83ea4ed Je l'ai utilisé comme référence (copier et coller).

scrape_google.py


import requests
import random
import shutil
import bs4
import ssl
import os.path
ssl._create_default_https_context = ssl._create_unverified_context

def image(keyword):
    Res = requests.get("https://www.google.com/search?hl=jp&q=" + keyword + "&btnG=Google+Search&tbs=0&safe=off&tbm=isch")
    Html = Res.text
    Soup = bs4.BeautifulSoup(Html,'lxml')
    links = Soup.find_all("img")
    link = random.choice(links).get("src")
    return link

def download_img(url, file_name, save_dir, img_num):
    try: 
        r = requests.get(url, stream=True)
        if r.status_code == 200:
                with open( os.path.join( save_dir, file_name, str(img_num)+".png " ) , 'wb') as f:
                    r.raw.decode_content = True
                    shutil.copyfileobj(r.raw, f)
    except:
        pass 



if __name__ == "__main__":
    num = 10
    keyword = "cat"
    save_dir = 'data'

    data_list = keyword.split(' ')
    data = keyword.lower()
    file_name_dir = '_'.join(data_list)
    file_name_dir = file_name_dir.lower() 

    if not os.path.exists(save_dir): 
        os.mkdir(save_dir) 
    if not os.path.exists( os.path.join( save_dir, file_name_dir ) ): 
        os.mkdir( os.path.join( save_dir, file_name_dir ) ) 


    for i in range(int(num)):
        try:
            print(f'{i} th attempt for crawl...')
            link = image(data)
            download_img(link, file_name_dir, save_dir, i)
        except:
            pass


Édition Yahoo

https://qiita.com/ishiwara51/items/3979fbc1c69b4f8ee2d3 Je me suis référé ici (entièrement copié).

scrape_yahoo.py


import os
import sys
import traceback
from mimetypes import guess_extension
from time import time, sleep
from urllib.request import urlopen, Request
from urllib.parse import quote
from bs4 import BeautifulSoup

MY_EMAIL_ADDR = ''

class Fetcher:
    def __init__(self, ua=''):
        self.ua = ua

    def fetch_img_direct(self, url):
        """
Extrait les informations d'octet de l'image affichée sur l'écran de recherche d'image Yahoo.
argument:
            url:L'URL de l'écran de recherche d'images Yahoo.

Valeur de retour:
            img_b_content:Une liste de codes d'octet pour les ressources du site Web.
            mime: CONTENT_L'extension spécifiée par TYPE.
        """
        req = Request(url, headers={'User-Agent': self.ua})
        try:
            with urlopen(req, timeout=3) as p:
                page_b_content = p.read()
                structured_page = BeautifulSoup(page_b_content.decode('UTF-8'), 'html.parser')
                img_link_elems = structured_page.find_all('img')
                img_urls = [e.get('src') for e in img_link_elems if e.get('src').startswith('http')]
                img_urls = list(set(img_urls)) #On ne sait pas pourquoi il est défini
        except:
            sys.stderr.write('Error in fetching {}\n'.format(url))
            sys.stderr.write(traceback.format_exc())
            return None, None

        img_b_content = []
        mime = []
        for i, img_url in enumerate(img_urls):
            req1 = Request(img_url, headers={'User-Agent': self.ua})
            try:
                with urlopen(req1, timeout=3) as p:
                    img_b_content.append(p.read())
                    mime.append(p.getheader('Content-Type'))
            except:
                sys.stderr.write('Error in fetching {}\n'.format(img_url))
                sys.stderr.write(traceback.format_exc())
                continue

        return img_b_content, mime

fetcher = Fetcher(MY_EMAIL_ADDR)



def url_brancher(word):
    """
Obtenez l'url de l'écran de recherche d'images Yahoo pour le nombre de combinaisons de conditions de recherche.

argument:
        word :Terme de recherche.

Valeur de retour:
        urllist :Une liste d'URL sur l'écran de recherche d'images Yahoo.
    """
    constant = "https://search.yahoo.co.jp/image/search?p={}&n=60".format(quote(word))

    values = [\
    ["", "small"],\
    ["", "red"],\
    ["", "face"]\
    ]
    """
    values = [\
    ["", "small", "medium", "large", "wallpaper", "widewallpaper"],\
    ["", "red", "orange", "yellow", "green", "teal", "blue", "purple", "pink", "white", "gray", "black", "brown"],\
    ["", "face", "photo", "clipart", "lineart"]\
    ]
    """
    urllist = []

    for i in range(len(values[0])):
        for j in range(len(values[1])):
            for k in range(len(values[2])):
                urllist.append(constant + "&dim={}".format(values[0][i]) + "&imc={}".format(values[1][j]) + "&ctype={}".format(values[2][k]))
    return urllist



def main(word):
    """
Enregistrez le fichier image en fonction des informations obtenues par Fetch.

argument:
    word:Terme de recherche.

Valeur de retour:
    """
    data_dir = 'data/'
    if not os.path.exists(data_dir):
        os.makedirs(data_dir)

    yahoo_url_list = url_brancher(word)

    for i, yahoo_url in enumerate(yahoo_url_list):
        sleep(0.1)
        img, mime = fetcher.fetch_img_direct(yahoo_url)
        if not mime or not img:
            print('Error in fetching {}\n'.format(yahoo_url))
            continue

        for j, img_url in enumerate(img):
            ext = guess_extension(mime[j].split(';')[0])
            if ext in ('.jpe', '.jpeg'):
                ext = '.jpg'
            if not ext:
                print('Error in fetching {}\n'.format(img_url))
                continue

            result_file = os.path.join(data_dir, str(i) + str(j)+ ext)
            with open(result_file, mode='wb') as f:
                f.write(img_url)
            print('fetched', str(i) + str(j) + ext)



if __name__ == '__main__':
    word = 'cat'
    main(word)

édition icrawler

icrawler Une bibliothèque qui vous permet d'explorer des images avec google, bing, baidu et Flickr. Mais peut-être que vous ne pouvez pas simplement explorer Google pour le moment? ?? Cependant, j'ai pu ramper avec Bing, Baidu et Flickr sans aucun problème. Veuillez noter que vous n'avez besoin que de la clé API pour Flickr (soyez assuré que cela prendra environ 2 minutes)

scrape_icrawler.py



import logging
import os.path as osp
from argparse import ArgumentParser

from icrawler.builtin import (BaiduImageCrawler, BingImageCrawler,
                              FlickrImageCrawler, GoogleImageCrawler,
                              GreedyImageCrawler, UrlListCrawler)


key_word = 'cat'
max_num = 200

def test_google():
    print('start testing GoogleImageCrawler')
    google_crawler = GoogleImageCrawler(
        downloader_threads=4,
        storage={'root_dir': 'images/google'},
        log_level=logging.INFO)
    search_filters = dict()
        # size='large',
        # color='orange',
        # license='commercial,modify',
        # date=(None, (2017, 11, 30)))
    google_crawler.crawl(key_word, filters=search_filters, max_num=max_num)


def test_bing():
    print('start testing BingImageCrawler')
    bing_crawler = BingImageCrawler(
        downloader_threads=2,
        storage={'root_dir': 'images/bing'},
        log_level=logging.INFO)
    search_filters = dict()
        # type='photo',
        # license='commercial',
        # layout='wide',
        # size='large',
        # date='pastmonth')
    bing_crawler.crawl(key_word, max_num=max_num, filters=search_filters)


def test_baidu():
    print('start testing BaiduImageCrawler')
    # search_filters = dict(size='large', color='blue')
    search_filters = dict()
    baidu_crawler = BaiduImageCrawler(
        downloader_threads=4, storage={'root_dir': 'images/baidu'})
    baidu_crawler.crawl(key_word, filters=search_filters, max_num=max_num)


def test_flickr():
    print('start testing FlickrImageCrawler')
    flickr_crawler = FlickrImageCrawler(
        apikey=None,
        parser_threads=2,
        downloader_threads=4,
        storage={'root_dir': 'images/flickr'})
    flickr_crawler.crawl(
        max_num=max_num,
        tags=key_word,
        tag_mode='all',
        )


def test_greedy():
    print('start testing GreedyImageCrawler')
    greedy_crawler = GreedyImageCrawler(
        parser_threads=4, storage={'root_dir': 'images/greedy'})
    greedy_crawler.crawl(
        'http://www.bbc.com/news', max_num=max_num, min_size=(100, 100))


def test_urllist():
    print('start testing UrlListCrawler')
    urllist_crawler = UrlListCrawler(
        downloader_threads=3, storage={'root_dir': 'images/urllist'})
    filelist = osp.join(osp.dirname(__file__), 'filelist_demo.txt')
    urllist_crawler.crawl(filelist)


def main():
    parser = ArgumentParser(description='Test built-in crawlers')
    parser.add_argument(
        '--crawler',
        nargs='+',
        # default=['google', 'bing', 'baidu', 'flickr', 'greedy', 'urllist'],
        default=['google', 'bing', 'baidu', 'flickr'],
        help='which crawlers to test')
    args = parser.parse_args()
    for crawler in args.crawler:
        eval('test_{}()'.format(crawler))
        print('\n')


if __name__ == '__main__':
    main()

Résumé

Ce serait bien de pouvoir rapidement explorer et collecter des images lorsque vous n'avez pas un grand ensemble de données. Je pense qu'il existe d'autres bonnes méthodes et sources d'images, alors j'espère pouvoir en essayer d'autres.

Recommended Posts

Résumé de l'exploration d'image effectuée à la vitesse d'une seconde
Collectez des images de chats à la vitesse d'une seconde et visez la tribu Cat Hills
[GoLang] Définissez un espace au début du commentaire
Jetez un œil au traitement de LightGBM Tuner
Tâches au démarrage d'un nouveau projet python
Qu'est-ce qu'un moteur de recommandation? Résumé des types
Obtenez UNIXTIME au début d'aujourd'hui avec une commande
J'ai fait une image ponctuelle de l'image d'Irasutoya. (partie 1)
Un résumé approximatif des différences entre Windows et Linux
Convertissez les données d'image (png) à portée de main en une image .pbm
J'ai fait une image ponctuelle de l'image d'Irasutoya. (partie 2)
Un bref résumé de Linux
L'image est Namekuji
Aiguille en or pour quand elle devient une pierre en regardant la formule du traitement d'image
Une méthode de conversion du style d'une image tout en préservant la couleur
Jetons un coup d'œil à la carte des fonctionnalités de YOLO v3
[Statistiques] Saisir l'image de la théorie de la limitation du pôle central avec un graphe
Considérez la vitesse de traitement pour déplacer le tampon d'image avec numpy.ndarray
[Go] Créez une commande CLI pour changer l'extension de l'image
Une commande pour vérifier facilement la vitesse du réseau sur la console
Un bref résumé de la collection Python
Un résumé approximatif de l'histoire du système d'exploitation
J'ai brièvement résumé les bits quantiques (débutants)
Pour l'instant, celui qui crée une page d'accueil avec Django à la vitesse d'une seconde et la publie sur Heroku (compatible Windows)
L'histoire de l'exportation d'un programme
Comment mettre un numéro de ligne au début d'un fichier CSV
[Mac] Créez un environnement Python 3.x à la vitesse la plus rapide à l'aide de Docker
[Big Query] Chargez une partie des données BQ dans les pandas à grande vitesse
Obtenez une instance datetime à tout moment de la journée en Python
2014/02/28 Résumé du contenu démo à #ssmjp, partie 1
Un mémorandum de la vitesse de diagonalisation arbitraire des degrés
Mesurer la force de l'association dans un tableau croisé
Criez Bonjour Reiwa! Au début de Reiwa!
[python] [meta] Le type de python est-il un type?
Un bref résumé de la vue d'ensemble de Pinax #djangoja
La deuxième nuit de la boucle avec pour
Un mémo expliquant la spécification de l'axe de l'axe
Cours de base Python (à la fin de 15)
Obtenez le nom de fichier du répertoire (glob)
L'histoire du traitement A du blackjack (python)
Notez l'achèvement d'une commande chronophage
Résumé des opérations souvent effectuées avec asyncpg
L'histoire de l'adresse IPv6 que je souhaite conserver au minimum
Je veux ajouter du silence pendant 1 seconde au début d'un fichier wav
Les prévisions épidémiques du nouveau virus corona ont été publiées sur le Web à une vitesse explosive
[AWS Lambda] Créer un package de déploiement à l'aide de l'image Amazon Linux Docker