[PYTHON] Collecte et automatisation d'images érotiques à l'aide du deep learning
introduction
Les images érotiques sont les meilleures.
N'importe qui peut faire des choses coquines librement tant qu'il a des images érotiques. Vous pouvez être sexuellement excité par vous-même, même si vous ne l'avez pas. Vous pouvez ressentir une certaine satisfaction et vous plonger dans le bonheur. Tous les goûts sont à votre disposition.
Par conséquent, pour nous, êtres humains, collecter des images érotiques n'est pas une exagération de l'appeler une habitude en tant qu'espèce, tout comme un scarabée de fumier roulant des excréments.
Cependant, nous sommes les plus longues créatures de primates. Cela ne devrait pas être la même chose que le dendroctone du fumier, qui fait rouler les excréments de la même manière depuis des dizaines de milliers d'années. C'est l'humanité qui collecte les images érotiques plus efficacement et avec plus d'enthousiasme.
Cependant, même ainsi, la collecte d'images érotiques est très difficile. Il est nécessaire de visiter différents sites, de les examiner attentivement, puis de collecter et de structurer les éléments montés selon un schéma fiable. De nombreuses personnes en auront besoin selon les jours.
À propos, récemment, l'apprentissage en profondeur est devenu populaire.
Les chats et la louche apprennent en profondeur.
Lorsque vous abordez un projet difficile, que pouvez-vous faire avec le deep learning? Le nombre de consultations comme celle-ci a augmenté. Si vous lancez un projet avec une faible précision de commande, ne pouvez-vous pas attirer l'attention des clients avec un apprentissage en profondeur pour le moment? N'est-ce pas populaire? Le nombre de vendeurs qui prétendent être comme ça a augmenté.
C'est la même chose même si je rencontre des ingénieurs extérieurs à l'entreprise, c'est donc une victoire facile en deep learning, non? Il y a plus d'occasions de parler de choses comme, qui seraient résolues par l'apprentissage en profondeur. Tout le monde et lui sont axés sur l'apprentissage profond.
Donc, si c'est si populaire, vous devez relever le défi.
J'ai essayé de collecter des images érotiques avec un apprentissage en profondeur.
la mise en oeuvre
J'ai utilisé le chainer pour la mise en œuvre.
C'est un produit national sûr et sécurisé.
Le modèle ressemble à ceci:
class NIN(chainer.Chain):
def __init__(self, output_dim, gpu=-1):
w = math.sqrt(2)
super(NIN, self).__init__(
mlpconv1=L.MLPConvolution2D(3, (16, 16, 16), 11, stride=4, wscale=w),
mlpconv2=L.MLPConvolution2D(16, (32, 32, 32), 5, pad=2, wscale=w),
mlpconv3=L.MLPConvolution2D(32, (64, 64, 64), 3, pad=1, wscale=w),
mlpconv4=L.MLPConvolution2D(64, (32, 32, output_dim), 3, pad=1, wscale=w),
)
self.output_dim = output_dim
self.train = True
self.gpu = gpu
def __call__(self, x, t):
h = F.max_pooling_2d(F.relu(self.mlpconv1(x)), 3, stride=2)
h = F.max_pooling_2d(F.relu(self.mlpconv2(h)), 3, stride=2)
h = F.max_pooling_2d(F.relu(self.mlpconv3(h)), 3, stride=2)
h = self.mlpconv4(F.dropout(h, train=self.train))
h = F.average_pooling_2d(h, 10)
h = F.reshape(h, (x.data.shape[0], self.output_dim))
loss = F.softmax_cross_entropy(h, t)
print(loss.data)
return loss
Comme vous pouvez le voir, je viens de jouer avec l'échantillon NIN fourni avec le chainer. De plus, la raison pour laquelle j'ai joué avec c'était que la mémoire du VPS pour le développement était petite, donc je ne pouvais pas entraîner un modèle plus compliqué. Même avec ce modèle, il faut environ 2 Go lors de l'apprentissage.
Pour les données d'apprentissage, j'ai utilisé les illustrations publiées sur Internet. Sur un total de 2000 images, 1000 images auxquelles le fils réagit sont des images rares, et 1000 images inattendues sont des images courantes, et la classification se situe entre les deux types.
Vérification
Les trois images suivantes ont été utilisées pour vérifier les résultats.
Le premier est la couverture de mon livre "Tanaka-Age Equals, a Wizard Who Has No History". Le second est ma belle-fille qui a demandé un voyage d'affaires à une fille 3D custom. Et le troisième est celui où j'ai apprécié le jeu de l'agresseur avec elle dans le train.
Nous avons noté ces trois images en utilisant le modèle ci-dessus.
En conséquence, les scores suivants ont été obtenus.
1er
{
"result": [
[
0.9290218353271484,
"1,rare"
],
[
0.07097823172807693,
"0,common"
]
]
}
Deuxième pièce
{
"result": [
[
0.6085503101348877,
"0,common"
],
[
0.3914496898651123,
"1,rare"
]
]
}
Troisième pièce
{
"result": [
[
0.5935600399971008,
"1,rare"
],
[
0.40644001960754395,
"0,common"
]
]
}
Semblable à l'échantillon imagenet fourni avec le chainer, plus la valeur de l'étiquette correspondante est élevée, plus elle est proche de cela. En d'autres termes, plus la valeur rare est élevée, plus le fils sera heureux.
À ce stade, j'ai ressenti une certaine réponse.
Par conséquent, afin de collecter des images érotiques de manière plus réaliste, nous allons accéder au modèle d'API ci-dessus, lire l'image acquise à partir de l'exploration en temps réel de Twitter, stocker le résultat dans la base de données et classer l'application Web. créé.
La configuration est la suivante.
version: '2'
volumes:
db-data:
driver: local
object-data:
driver: local
services:
db:
container_name: db
image: mysql
volumes:
- db-data:/var/lib/mysql
# - ./dockerfiles/staging/mysql:/docker-entrypoint-initdb.d
environment:
MYSQL_ROOT_PASSWORD: $APP_DATABASE_PASSWORD
MYSQL_DATABASE: app_staging
MYSQL_USER: xxxx
MYSQL_PASSWORD: $APP_DATABASE_PASSWORD
expose:
- "3306"
restart: always
app:
build:
context: ../../
dockerfile: dockerfiles/staging/app/Dockerfile
environment:
RAILS_LOG_TO_STDOUT: 'true'
RAILS_SERVE_STATIC_FILES: 'true'
RAILS_ENV: 'staging'
DISABLE_DATABASE_ENVIRONMENT_CHECK: $DISABLE_DATABASE_ENVIRONMENT_CHECK
APP_SECRET_KEY_BASE: $APP_SECRET_KEY_BASE
APP_DATABASE_USERNAME: xxxx
APP_DATABASE_PASSWORD: $APP_DATABASE_PASSWORD
APP_DATABASE_HOST: db
TW_CONSUMER_KEY: $TW_CONSUMER_KEY
TW_CONSUMER_SECRET: $TW_CONSUMER_SECRET
TW_ACCESS_TOKEN: $TW_ACCESS_TOKEN
TW_ACCESS_TOKEN_SECRET: $TW_ACCESS_TOKEN_SECRET
minio:
build:
context: ../../
dockerfile: dockerfiles/staging/minio/Dockerfile
volumes:
- object-data:/var/lib/minio
environment:
MINIO_ACCESS_KEY: 'xxx'
MINIO_SECRET_KEY: 'xxx'
ports:
- '0.0.0.0:9000:9000'
command: [server, /export]
calc:
container_name: calc
build:
context: ../../
dockerfile: dockerfiles/staging/calc/Dockerfile
command: python web.py
expose:
- "5000"
web:
container_name: web
extends:
service: app
command: bin/wait_for_it db:3306 -- pumactl -F config/puma.rb start
expose:
- "3000"
depends_on:
- db
crawler:
container_name: crawler
extends:
service: app
command: bin/wait_for_it db:3306 -- rails runner bin/crawler.rb
depends_on:
- calc
- db
nginx:
container_name: nginx
build:
context: ../../
dockerfile: dockerfiles/staging/nginx/Dockerfile
ports:
- '80:80'
- '443:443'
depends_on:
- web
J'ai essayé de collecter des plats d'accompagnement sur Twitter pendant un certain temps en utilisant cela.
Les résultats sont les suivants.
Certains d'entre eux sont extraits du classement lorsque 5,60 feuilles environ sont collectées.
La valeur indiquée sur le côté droit de l'image est la valeur de rare.
Je suis surpris que les résultats obtenus jusqu'à présent aient été obtenus simplement en donnant au modèle les illustrations divisées en A et B sans rien faire. Je sentais fortement qu'il serait possible de collecter des images que mon fils aimait plus en les étiquetant un peu plus strictement. De plus, si vous utilisez plusieurs modèles en combinaison, la précision est susceptible de s'améliorer davantage.
- Diverses valeurs pour les images affichées seront jugées par une IA qui a appris le goût de mon fils. La valeur ne nie pas un passe-temps ou un principe particulier.
Conclusion
Peut-être que le jour où chaque personne aura une image érotique de sommelier optimisée pour lui-même est à nos portes.
Recommended Posts