Présentation Je ne peux pas faire confiance au contenu du site de bouche à oreille. J'ai pensé que ce serait intéressant si je pouvais juger de l'authenticité du contenu publié par l'apprentissage automatique. Utilisez l'API Google Prediction pour déterminer l'authenticité de votre message.

Prérequis ・ Enregistré sur Google Cloud Platform (disponible gratuitement dans un premier temps) -Création d'un projet Cloud Platform Console (obtention d'un ID de projet) -Vous avez activé Prediction et Google Cloud Storage API pour votre projet. ・ Création de seau -Téléchargez les données d'entraînement sur Cloud Storage. ・ Définir le nom du modèle -Obtenir le fichier d'authentification API (client_secrets.json) ↓ Si vous le regardez une fois à l'aide de l'API Google Prediction, vous pouvez voir l'image entière. https://cloud.google.com/prediction/docs/quickstart?hl=ja

Diagramme de séquence

Capture d'écran 2017-05-20 13.05.20.png

prediction_service.commande d'exécution py:
python prediction_service.py "k_prediction/language.txt" "language-identifier" "Projet<img width="841" alt="Capture d'écran 2017-05-20 13.05.20.png " src="https://qiita-image-store.s3.amazonaws.com/0/95254/cc3adb89-1330-77e9-bf2a-f32fa94f5b55.png ">
ID"

Exécuter le traitement par lots (prediction_service.py) ``` #Fichier: prédiction_service.py
#!/usr/bin/env python

-- coding: utf-8 --

Copyright 2014 Google Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");

you may not use this file except in compliance with the License.

You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software

distributed under the License is distributed on an "AS IS" BASIS,

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

See the License for the specific language governing permissions and

limitations under the License.

"""Simple command-line sample for the Google Prediction API Command-line application that trains on your input data. This sample does the same thing as the Hello Prediction! example. You might want to run the setup.sh script to load the sample data to Google Storage. Usage: $ python prediction_service.py "bucket/object" "model_id" "project_id" "my-xxxxx.json" You can also get help on all the command-line flags the program understands by running: $ python prediction_service.py --help To get detailed log output run: $ python prediction_service.py --logging_level=DEBUG """ from future import print_function

author = ('[email protected] (Joe Gregorio), ' '[email protected] (Marc Cohen)')

import argparse import os from pprint import pprint as pp import sys import time import MySQLdb

sys.path.append( os.path.join(os.path.dirname(os.path.realpath(file)), 'lib') )

import httplib2 from apiclient import discovery from apiclient import sample_tools from oauth2client import client from oauth2client.service_account import ServiceAccountCredentials from googleapiclient import discovery from oauth2client import tools

Time to wait (in seconds) between successive checks of training status.

SLEEP_TIME = 10 scopes=['https://www.googleapis.com/auth/prediction','https://www.googleapis.com/auth/devstorage.read_only']


 → 1. Définir les informations d'authentification

#Declare command-line flags. argparser = argparse.ArgumentParser(add_help=False) argparser.add_argument('object_name', help='Nom du godet/hoge.txt(Données d'entraînement)') argparser.add_argument('model_id', help='ID de modèle') argparser.add_argument('project_id', help='ID du projet') argparser.add_argument('credential', help='client_secrets.json')

def print_header(line): '''Format and print header block sized to length of line''' header_str = '=' header_line = header_str * len(line) print('\n' + header_line) print(line) print(header_line)

def main(argv):

create flags

parents=[argparser] parent_parsers = [tools.argparser] parent_parsers.extend(parents) parser = argparse.ArgumentParser( description=doc, formatter_class=argparse.RawDescriptionHelpFormatter, parents=parent_parsers) flags = parser.parse_args(argv[1:]) credential_file = os.path.join(os.path.dirname(os.path.realpath(file)), flags.credential) credentials = ServiceAccountCredentials.from_json_keyfile_name( credential_file, scopes=scopes)

http = credentials.authorize(http = httplib2.Http()) service = discovery.build('prediction', 'v1.6', http=http)

 → 2. Accédez à l'API Google Prediction

try: # Get access to the Prediction API. papi = service.trainedmodels()

→　3. List models.

# List models.
print_header('Fetching list of first ten models')
result = papi.list(maxResults=10, project=flags.project_id).execute()
print('List results:')
pp(result)

→　4. Start training request on a data set.

# Start training request on a data set.
print_header('Submitting model training request')
body = {'id': flags.model_id, 'storageDataLocation': flags.object_name}
start = papi.insert(body=body, project=flags.project_id).execute()
print('Training results:')
pp(start)

→　5. wait for the training to complete.

# Wait for the training to complete.
print_header('Waiting for training to complete')
while True:
  status = papi.get(id=flags.model_id, project=flags.project_id).execute()
  state = status['trainingStatus']
  print('Training state: ' + state)
  if state == 'DONE':
    break
  elif state == 'RUNNING':
    time.sleep(SLEEP_TIME)
    continue
  else:
    raise Exception('Training Error: ' + state)

  # Job has completed.
  print('Training completed:')
  pp(status)
  break

→　6. Describe model

# Describe model.
print_header('Fetching model description')
result = papi.analyze(id=flags.model_id, project=flags.project_id).execute()
print('Analyze results:')
pp(result)

 → 7. Récupérez les données à prédire de la base de données

#Appel DB
print('＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝')
print('Obtenez les données à prédire à partir de la base de données')
print('＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝')

if __name__ == "__main__":

  connector = MySQLdb.connect(host="??????", db="??????", user="??????", passwd="??????", charset="utf8")
  cursor = connector.cursor()

  sql = "SELECT id,message FROM `posts` WHERE id = (select MAX(id) from posts)"
  cursor.execute(sql)
  records = cursor.fetchall()
  for record in records:
      print (record[0])
      record_id=record[0]
      record_1=record[1].encode('utf-8')
  cursor.close()
  connector.close()
  #tst

# Make some predictions using the newly trained model.
print_header('Making some predictions')
for sample_text in [record_1]:
  body = {'input': {'csvInstance': [sample_text]}}
  result = papi.predict(
    body=body, id=flags.model_id, project=flags.project_id).execute()
  print('Prediction results for "%s"...' % sample_text)
  pp(result)

  import json
  array = json.dumps(result)
  data=json.loads(array)
  data2 = data['outputMulti']
  print(data2)

 → 8. Afficher les données de réponse de l'API

  print('＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝')
  print('Afficher les données de réponse de l'API')
  print('＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝')
  print(data2[0]['label'])
  print(data2[0]['score'])
  print(data2[1]['label'])
  print(data2[1]['score'])
  data_score=float(data2[0]['score'])-float(data2[1]['score'])

 → 9. Juger les données de réponse de l'API

  print('＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝')
  print('Juger les données de réponse de l'API')
  print('＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝') 
  if data_score > 0 :
    pacentage=float(data2[0]['score'])*100
        print( "Ce message est'"+str(pacentage)+"%''true'est.")
        evaluate = data2[0]['label']
    score = data2[0]['score']
  else: 
    pacentage=float(data2[1]['score'])*100
    print( "Ce message est'"+str(pacentage)+"%''false'est.") 
        evaluate = data2[1]['label']
        score = data2[1]['score']
        print(record_id)
   #Appel DB

 → 10. Refléter le résultat dans la base de données

print('＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝')
print('Refléter le résultat dans la base de données')
print('＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝')

if __name__ == "__main__":
  connector = MySQLdb.connect(host="?????", db="?????", user="?????", passwd="?????", charset="utf8")
  cursor = connector.cursor()
  cursor.execute('UPDATE posts SET evaluate  = (%s) WHERE id = (%s)',([evaluate],record_id))
  cursor.execute('UPDATE posts SET score  = (%s) WHERE id = (%s)',([score],record_id))
  connector.commit()
  connector.close()

if name == 'main': main(sys.argv)


 → 11. Refléter le résultat du jugement enregistré dans le DB dans l'article nouvellement publié par l'application WEB.

 Site de référence
https://github.com/google/google-api-python-client/tree/master/samples/prediction

 <h2> Préparation </ h2>
 -Création d'un projet Cloud Platform Console (obtention d'un ID de projet)
 -Vous avez activé Prediction et Google Cloud Storage API pour votre projet.
 ・ Création de seau
 -Téléchargez les données d'entraînement sur Cloud Storage.
 ・ Définir le nom du modèle
 -Obtenir le fichier d'authentification API (client_secrets.json)
https://cloud.google.com/prediction/docs/quickstart?hl=ja

 <h3> Comment obtenir client_secrets.json </ h3>
 J'ai utilisé c pour faire l'authentification API.
 Je décrirai brièvement la procédure de création de client_secrets.json.

 procédure
 → Enregistrez le projet sur la Google Developer Console
 → Activez l'API Google Agenda depuis "API et authentification" → "API" à gauche
 → Depuis «API et authentification» → «Identifiants» à gauche, appuyez sur «Créer un nouvel ID client» → «Applications installées (autres)» «Télécharger JSON» et enregistrez-le sous client_secrets.json

Nom de fichier: client_secrets.json

{ "web": { "client_id": "?????", "client_secret": "?????", "redirect_uris": [], "auth_uri": "https://accounts.google.com/o/oauth2/auth", "token_uri": "https://accounts.google.com/o/oauth2/token" } }

 <h3> Créer des données d'entraînement </ h3>
 Que sont les données d'entraînement?
 Ce sont les données qui sont à la base du jugement par l'apprentissage automatique.
 En expliquant les données de formation, je vais expliquer brièvement l'apprentissage des opportunités.
 Il existe à peu près deux types de problèmes traités par l'apprentissage automatique: «l'apprentissage supervisé» et «l'apprentissage non supervisé».
 L'API Google Prediction est l'ancien apprentissage supervisé.
 Dans l'apprentissage supervisé, le but est de prédire correctement la sortie (invisible) des données d'entrée (visibles) données. Cependant, la machine ne sait pas quoi sortir même si l'entrée n'est qu'une entrée.
 Par conséquent, plusieurs cas de paires d'entrée / sortie appelées données de formation (ou données d'enseignant) sont donnés.
 En d'autres termes, demandez aux humains de donner des exemples que si vous pouvez mettre cela, éteignez-le.
 Sur cette base, le but est de créer une machine (= fonction) qui produit la sortie correcte lorsque de nouvelles données d'entrée arrivent.
 Bien sûr, si vous obtenez exactement la même entrée que vous avez vue jusqu'à présent, il semble suffisant de sélectionner les données d'entraînement avec la même entrée et de les sortir, mais elles sont moyennes. Certaines données d'entrée n'apparaissent pas dans les données d'entraînement dont vous disposez.
 Pour de telles données, il s'agit d'un apprentissage supervisé pour concevoir une procédure d'apprentissage (algorithme d'apprentissage) qui généralise des données d'apprentissage données et maximise la capacité de traiter des données de sortie inconnue. C'est le thème principal.

 <h3> Données d'entraînement </ h3>
 Comme expliqué ci-dessus, ces données sont un ensemble d'exemples de paires d'entrée / sortie.
 Il renvoie true lorsque le caractère hoge est entré et false lorsque le caractère hoge_false est entré.

train.txt

"true","hoge" "true","hoge" "true","hoge" "true","hoge" "true","hoge" "true","hoge" "true","hoge" "true","hoge" "true","hoge" "true","hoge" "false","hoge_false" "false","hoge_false" "false","hoge_false" "false","hoge_false" "false","hoge_false" "false","hoge_false" "false","hoge_false" "false","hoge_false"


 <h2> Construction de l'environnement </ h2>
 Décrit les informations nécessaires pour créer un environnement de développement
 <h3> Environnement Python </ h3>

yum install mysql-server mysql mysql-devel

chkconfig mysqld on

chkconfig --list | grep mysql

service mysqld start

exit #<= ec2-Retour à l'utilisateur

 <h3> Installez les outils nécessaires (tels que gcc) avant d'installer MySQL-python </ h3>

$ sudo yum groupinstall "Development Tools" Si ça ne marche pas $sudo yum install gcc　 MySQL-installation de python: $ pip install MySQL-python


 <h3> Vérifier avec le script de connexion MySQL </ h3>

file name : test_connection_mysql.py

import _mysql import sys from pprint import pprint as pp try: con = _mysql.connect('localhost', 'root', 'root', 'prediction_dev') #Modifier ici help(con) except _mysql.Error, e: print "Error %d: %s" % (e.args[0], e.args[1]) sys.exit(1) finally: if con: con.close()

$ python test_connection_mysql.py <_mysql.connection open to 'localhost' at 265f940>

Vous pouvez vous connecter sans aucune erreur.

 Ceci termine la construction de l'environnement pour l'apprentissage automatique avec Python.

Déterminez l'authenticité des articles publiés par machine learning (API Google Prediction).