[PYTHON] J'ai essayé de collecter automatiquement des images érotiques de Twitter à l'aide de l'API Cloud Vision de GCP

introduction

Premier message et je viens de commencer à apprendre la programmation, il y a donc beaucoup de phrases et de codes pauvres, mais j'espère que vous pourrez le lire.

Motivation

Lorsque je parcourais des images sur Twitter, j'étais stressé par de nombreux tweets et images contenant uniquement du texte autre que le genre cible. Par conséquent, j'ai pensé que ce serait mieux si je ne pouvais extraire que ceux désirés. (Résumé: je veux des images érotiques)

Préparation

Obtenez une clé API pour utiliser l'API Cloud Vision Cet article a été utile

L'API Twitter s'applique à l'utilisation et obtient une clé API et un jeton. Cela prend un peu de temps et d'efforts car il est nécessaire de décrire l'utilisation prévue en anglais. Cet article a été utile

Les trois bibliothèques tierces suivantes sont utilisées. Tous peuvent être installés avec pip.

1. schedule
2. tweepy
3. requests

Flux de traitement approximatif

1. Obtenez des tweets de la chronologie Twitter
2. Enregistrez l'image à partir de l'URL si le tweet contient une image
3. Envoyez l'image à l'API Cloud Vision pour analyse
4. Supprimer tout sauf ceux jugés adultes

la mise en oeuvre

main.py

import base64
import json
import os
import pickle
import time

import schedule
import tweepy
import requests

Importez la bibliothèque.

main.py

API_KEY        = 'Twitter API key'
API_SECRET_KEY = 'Twitter API secret key'
ACCESS_TOKEN        = 'Twitter Access token'
ACCESS_TOKEN_SECRET = 'Twitter Access token secret'

CVA_API_KEY = "Cloud Vision API key"

Conservez chaque clé que vous avez obtenue.

Extraire les données nécessaires de Twitter

Tout d'abord, obtenez le TL qui est la source du tweet. Cette fois, j'utilise list_timeline parce que je veux extraire les tweets du compte ajouté à la liste, mais je pense qu'il est également bon d'utiliser user_timeline, etc. pour se limiter à un compte spécifique.

main.py

auth = tweepy.OAuthHandler(API_KEY, API_SECRET_KEY)
auth.set_access_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)


api = tweepy.API(auth, wait_on_rate_limit=True)


#Obtenez des tweets de la chronologie
def main():
    with open('before_tl.pickle', 'rb') as f:
        before_tl = pickle.load(f)
    tl = api.list_timeline(owner_screen_name="Identifiant Twitter de l'administrateur de la liste", slug="Le nom de la liste que vous souhaitez obtenir")
    with open('before_tl.pickle', 'wb') as f:
        pickle.dump(tl, f)
    for tweet in reversed(tl):    #Tweet, inversé pour trier l'heure RT par ordre chronologique
        if not tweet in before_tl:
            media_getter(tweet)

La raison d'économiser TL avec pickle est d'éviter de surpasser l'API GCP de paiement à l'utilisation. Lors du passage d'un tweet de TL, il est assemblé avec le TL précédent et le traitement n'est exécuté que pour les nouveaux tweets.

main.py

#Nom d'écran de l'utilisateur à partir du Tweet(ID)Avoir
def username_geter(tweet):
    if 'RT' in tweet.text:
        return tweet.retweeted_status.user.screen_name
    return tweet.user.screen_name


#Obtenez la liste d'URL des images
def media_getter(tweet):
    try:
        medialist = [d.get('media_url') for d in tweet.extended_entities["media"]]
        name = username_geter(tweet)
        for media in medialist:
            img_save(media,name)
    except:
        print('Text Only')

Le nom d'écran de l'utilisateur est utilisé comme nom de fichier lors de l'enregistrement de l'image.

Ceci termine le processus d'obtention de l'URL de l'image à partir de Twitter.

Processus de stockage d'images

À partir de là, vous pouvez enregistrer l'image et la transmettre à Cloud Vision pour analyse.

main.py

#Enregistrez l'image à partir de l'URL et changez la destination de sauvegarde en fonction du jugement
def img_save(media,name):
    url_path = media.split("/")[-1]
    file_name = "adult/" + name + url_path

    response = requests.get(media)
    image = response.content

    with open(file_name, "wb") as f:
        f.write(image)
    identify = img_sort(file_name)

    if identify == "adult":
        print('---saved image---')
    else:
        import os
        os.remove(file_name)

   


#Renvoie un jugement en fonction du résultat
def img_sort(img_path):
    res_json = img_judge(img_path)
    judgement = res_json['responses'][0]['safeSearchAnnotation']['adult']

    if judgement == "POSSIBLE":
        print(judgement)
        return "possible"
    elif judgement == "LIKELY" or judgement == "VERY_LIKELY":
        print(judgement)
        return "adult"
    else:
        print(judgement)


#Envoyez des images à cloudvisoinapi et recevez des résultats
def img_judge(image_path):
    api_url = 'https://vision.googleapis.com/v1/images:annotate?key={}'.format(CVA_API_KEY)
    with open(image_path, "rb") as img:
        image_content = base64.b64encode(img.read())
        req_body = json.dumps({
            'requests': [{
                'image': {
                    'content': image_content.decode('utf-8')
                },
                'features': [{
                    'type': 'SAFE_SEARCH_DETECTION'
                }]
            }]
        })
        res = requests.post(api_url, data=req_body)
        return res.json()

La destination de sauvegarde de l'image est déterminée en divisant l'URL par "/" et en la listant, et en combinant le dernier répertoire extrait avec le nom d'écran et le répertoire.

L'image enregistrée est transmise à l'API et le processus est ramifié en fonction du résultat renvoyé. Cliquez ici pour voir la valeur renvoyée (https://cloud.google.com/vision/docs/reference/rpc/google.cloud.vision.v1?hl=ja#google.cloud.vision. v1.SafeSearchAnnotation).

Il s'agit d'une spécification pour enregistrer LIKELY (très probablement) et au-dessus et supprimer les autres, mais cette fois, j'ai changé la destination de sauvegarde en fonction du jugement pour vérifier l'exactitude de Cloud Vision.

main.py

import shutil

elif identify == "possible":
    new_file_name = "possible/" + name + url_path
    shutil.move(file_name, new_file_name)
    print('---saved possibleimage---')
else:
    new_file_name = "other/" + name + url_path
    shutil.move(file_name, new_file_name)
    print('---saved otherimage---')

Courir

Faisons le. Le traitement est effectué toutes les 8 secondes en utilisant la planification.

main.py

if __name__ == "__main__":
    schedule.every(8).seconds.do(main)
    while True:
        schedule.run_pending()
        time.sleep(1)

Résultat d'exécution

(Parce qu'il utilise une image tierce, l'image est floue)

J'ai pu extraire en toute sécurité et enregistrer uniquement les images érotiques. C'est un chef-d'œuvre que les images s'ajoutent de plus en plus. Il a été confirmé que la précision était assez élevée par rapport à celle jugée POSSIBLE. Tout ce que vous pouvez voir est jugé PROBABLE ou supérieur.

Épilogue

Cette fois, j'ai utilisé SAFE_SEARCH_DETECTION (la possibilité de déterminer si une image contient du contenu nuisible), mais il existe de nombreuses autres fonctionnalités dans l'API Cloud Vision. Si vous faites bon usage de la fonction, vous pouvez l'utiliser pour diverses collections et classifications d'images.

Les références

Essayez TEXT_DETECTION de l'API Google Cloud Vision en Python J'ai essayé d'utiliser l'API Google Cloud Vision Comment utiliser Tweety ~ Partie 1 ~ [Obtenir un Tweet]