[JAVA] Essayez d'obtenir l'état de la surface de la route en utilisant de grandes données de gestion de la surface de la route

Actuellement, en tant qu '«expérience de démonstration de la sophistication de la gestion de la surface des routes», les données acquises par des capteurs bon marché attachés aux véhicules de transport public tels que les bus et les taxis sont collectées et des données volumineuses qui les regroupent sont diffusées.

** Concours de données ouvertes Big Data pour la gestion de la chaussée ** http://micrms.force.com/apis

Cette fois, nous avons permis de vérifier l'état de la chaussée sur la carte à l'aide de ces données.

** Affichage de l'état de la surface de la route ** http://needtec.sakura.ne.jp/road_mgt/road_mgt.html

GitHub https://github.com/mima3/road_mgt

路面3.png

À propos de l'API d'expérience de démonstration dans la sophistication de la gestion de la chaussée

Les spécifications de l'API peuvent être téléchargées à partir de ce qui suit. http://micrms.force.com/developer

Les données peuvent être grossièrement divisées en trois. -Données de mesure de surface de route Données mesurées par une machine appelée i-DRIMS. Accélération, vitesse angulaire, données de position ・ Données sur l'état de la surface de la route Données sur l'état de la surface de la route obtenues en analysant les données de mesure de la surface de la route ・ Données de spécification de la surface de la route Informations sur la gestion des routes définies dans une courte section pour chaque gouvernement local

Normalement, vous utiliserez les données sur l'état de la surface de la route et les données de spécification de la surface de la route.

Comment obtenir des données sur l'état de la surface de la route

Pour obtenir l'état de la surface de la route, accédez à l'URL suivante.

http://roadmgt.herokuapp.com/api/v1/datapoints?data_type=road-surface

Le résultat est XML comme ceci:

<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:geo="http://www.w3.org/2003/01/geo/wgs84_pos#" xmlns:rm="http://roadmgt.herokuapp.com/vocab/rm#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#">
  <rdf:Description rdf:about="http://roadmgt.herokuapp.com/api/v1/datapoints/road-surface_282">
    <rm:iri>2.65</rm:iri>
    <rm:step>0.0</rm:step>
    <rm:patching_num>0</rm:patching_num>
    <rm:municipality_id>1</rm:municipality_id>
    <rm:too_slow_fast_flag>0</rm:too_slow_fast_flag>
    <rm:subsidence_and_puddle>0.0</rm:subsidence_and_puddle>
    <rm:section_id>-1</rm:section_id>
    <rm:speed>37.55711977</rm:speed>
    <rdf:type>http://roadmgt.herokuapp.com/vocab/rm#road-surface</rdf:type>
    <geo:alt>0.0</geo:alt>
    <rm:rms>21.14314346</rm:rms>
    <geo:long>140.1434769</geo:long>
    <rm:rutting_amount>3.75</rm:rutting_amount>
    <rm:pothole_num>0</rm:pothole_num>
    <rm:speed_fluctuation_flag>0</rm:speed_fluctuation_flag>
    <rdfs:label>road-surface_282</rdfs:label>
    <rm:cracking_rate>5.3</rm:cracking_rate>
    <geo:lat>35.61753776</geo:lat>
    <rm:analysis_timestamp>2014-12-30 17:00:02.0</rm:analysis_timestamp>
    <rm:distance>220</rm:distance>
  </rdf:Description>
  <rdf:Description rdf:about="http://roadmgt.herokuapp.com/api/v1/datapoints/road-surface_294">
    <rm:speed_fluctuation_flag>1</rm:speed_fluctuation_flag>
    <rm:patching_num>0</rm:patching_num>
    <rm:iri>2.5</rm:iri>
    <rm:step>0.0</rm:step>
    <rm:too_slow_fast_flag>0</rm:too_slow_fast_flag>
    <rm:subsidence_and_puddle>0.0</rm:subsidence_and_puddle>
    <rm:section_id>-1</rm:section_id>
    <rm:municipality_id>1</rm:municipality_id>
    <rm:distance>340</rm:distance>
    <geo:alt>0.0</geo:alt>
    <rm:cracking_rate>7.5</rm:cracking_rate>
    <geo:long>140.1464737</geo:long>
    <rdf:type>http://roadmgt.herokuapp.com/vocab/rm#road-surface</rdf:type>
    <rm:rms>26.23188158</rm:rms>
    <geo:lat>35.61759593</geo:lat>
    <rm:pothole_num>0</rm:pothole_num>
    <rm:speed>42.15859739</rm:speed>
    <rm:analysis_timestamp>2014-12-30 17:00:02.0</rm:analysis_timestamp>
    <rm:rutting_amount>5.3</rm:rutting_amount>
    <rdfs:label>road-surface_294</rdfs:label>
  </rdf:Description>
Abréviation
</rdf:RDF>

Comment obtenir toutes les données sur l'état de la chaussée

Le nombre maximum d'acquisitions lors de l'exécution de l'API est de 300 par défaut. Pour obtenir les données suivantes, vous devez utiliser le décalage comme indiqué ci-dessous.

(1) Commencez par commencer http://roadmgt.herokuapp.com/api/v1/datapoints?data_type=road-surface&limit=300&offset=0

(2) Si vous pouvez obtenir les données normalement, modifiez le décalage et exécutez-le. http://roadmgt.herokuapp.com/api/v1/datapoints?data_type=road-surface&limit=300&offset=300

(3) Répétez ceci jusqu'à ce que la réponse suivante soit obtenue.

404 notFound

Paramètres de l'état de la surface de la route

Les conditions de surface de la route peuvent être filtrées en spécifiant des paramètres. Les paramètres pouvant être spécifiés sont les suivants.

Nom Moule La description
municipality xsd:int Identifiant municipal
Cela semble être la pièce d'identité du gouvernement local, mais je ne comprends pas le sens car il n'y a pas d'explication comme la bonne.
Contient 1 et 11. Peut-être que 1 est la ville de Chiba et 11 est la ville de Toyonaka.
section xsd:int ID de section. Peut-être que la section de la route reçoit un identifiant unique en interne, mais je ne suis pas sûr.-Il y a 1 ou quelque chose.
date_start xsd:date Date d'analyse. Erreur si non définie avec la spécification de fin(YYYY-MM-DD)
date_end xsd:date Date d'analyse. Erreur si non définie avec la spécification de démarrage(YYYY-MM-DD)
lat_start xsd:double Début de la latitude. Erreur si non définie avec la spécification de fin
lat_end xsd:double Fin de la latitude. Erreur si non définie avec la spécification de démarrage
lon_start xsd:double Commencer la longitude. Erreur si non définie avec la spécification de fin
lon_end xsd:double Fin de longitude. Erreur si non définie avec la spécification de démarrage

Exemple d'exécution avec longitude et latitude spécifiées:

http://roadmgt.herokuapp.com/api/v1/datapoints?data_type=road-surface&lat_start=34.66802946&lon_start=135.362425&lat_end=35.67436512&lon_end=140.2823427&offset=300&limit=300

Mise en garde Si vous spécifiez les paramètres introduits ici et des paramètres autres que le décalage et la limite, une erreur se produira. Cela signifie qu'un code comme celui ci-dessous entraînera une erreur.

$.ajax({
  type : 'GET',
  url : 'http://roadmgt.herokuapp.com/api/v1/datapoints',
  cache: false //Éviter le cache entraînera une erreur.
  data : {
    data_type : 'road-surface',
    lat_start  : lat_start,
    lon_start : lon_start,
    lat_end  : lat_end,
    lon_end  : lon_end,
    offset : offset,
    limit : limit
  },
  success : function (data) {
  },
  'error' :  function(xhr, textStatus, error) {
  }
});

Cela implique le risque que le contenu ne change pas même si les données sont mises à jour dans le système IE.

Dans le cas de cahce = false, en spécifiant une valeur temporaire unique pour le paramètre, il est reconnu comme une autre requête et évite l'utilisation du cache, mais ce n'est pas disponible.

http://stackoverflow.com/questions/4303829/how-to-prevent-a-jquery-ajax-request-from-caching-in-internet-explorer

Spécification de la cible directe

Vous pouvez obtenir la cible directement en spécifiant l'URI décrit dans rdf: about.

Exemple d'exécution: http://roadmgt.herokuapp.com/api/v1/datapoints/road-surface_282

Résultat d'acquisition:

<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:geo="http://www.w3.org/2003/01/geo/wgs84_pos#" xmlns:rm="http://roadmgt.herokuapp.com/vocab/rm#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#">
<rdf:Description rdf:about="http://roadmgt.herokuapp.com/api/v1/datapoints/road-surface_282">
<rm:iri>2.65</rm:iri>
<rm:step>0.0</rm:step>
<rm:patching_num>0</rm:patching_num>
<rm:municipality_id>1</rm:municipality_id>
<rm:too_slow_fast_flag>0</rm:too_slow_fast_flag>
<rm:subsidence_and_puddle>0.0</rm:subsidence_and_puddle>
<rm:section_id>-1</rm:section_id>
<rm:speed>37.55711977</rm:speed>
<rdf:type>http://roadmgt.herokuapp.com/vocab/rm#road-surface</rdf:type>
<geo:alt>0.0</geo:alt>
<rm:rms>21.14314346</rm:rms>
<geo:long>140.1434769</geo:long>
<rm:rutting_amount>3.75</rm:rutting_amount>
<rm:pothole_num>0</rm:pothole_num>
<rm:speed_fluctuation_flag>0</rm:speed_fluctuation_flag>
<rdfs:label>road-surface_282</rdfs:label>
<rm:cracking_rate>5.3</rm:cracking_rate>
<geo:lat>35.61753776</geo:lat>
<rm:analysis_timestamp>2014-12-30 17:00:02.0</rm:analysis_timestamp>
<rm:distance>220</rm:distance>
</rdf:Description>
</rdf:RDF>

En spécifiant le nom de la propriété après le nom de la cible, vous ne pouvez obtenir que la propriété. À ce stade, il est nécessaire de remplacer ":" par "_". Par exemple, si vous voulez obtenir "rm: step", spécifiez "rm_step".

Exemple d'exécution: http://roadmgt.herokuapp.com/api/v1/datapoints/road-surface_282/rm_step

Résultat d'acquisition

<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:geo="http://www.w3.org/2003/01/geo/wgs84_pos#" xmlns:rm="http://roadmgt.herokuapp.com/vocab/rm#">
<rdf:Description rdf:about="http://roadmgt.herokuapp.com/api/v1/datapoints/road-surface_282">
<rm:step>0.0</rm:step>
</rdf:Description>
</rdf:RDF>

Description de la réponse

Les principales propriétés sont expliquées ci-dessous.

Propriété Nom Moule La description
rm:analysis_timestamp Date et heure de l'analyse xsd:dateTime 「2015-01-14 09:01:Il est au format "57".
rm:iri IRI xsd:double Indice international de rugosité Planéité objective (confort de roulement) de la chaussée.Échelle à évaluer
http://www.kandoken.jp/huroku/130913_2_kouenshiryo.pdf
rm:pothole_num Nombre de nids-de-poule xsd:int Nombre de trous créés par la dépression de la surface de la chaussée de la route
rm:patching_num Nombre de patchs xsd:int Nombre de mesures de premiers secours prises contre les dommages aux chaussées
http://www.mlit.go.jp/road/ir/ir-council/pdf/roadstock05.pdf
rm:cracking_rate Taux de fissure xsd:double http://www.town.oki.fukuoka.jp/file/gyousei/nyuusatsu/FILE_346_45.pdf
rm:rutting_amount Profondeur de l'orniérage xsd:double http://www.fuzita.org/cod/rut_.html
rm:step Étape xsd:double
rm:subsidence_and_puddle Naufrage / flaque d'eau xsd:double
geo:lat latitude xsd:double
geo:long longitude xsd:double
geo:alt Altitude xsd:double

Comment obtenir des données de surface de route

C'est fondamentalement le même que l'état de la chaussée. Accédez à l'URL suivante.

http://roadmgt.herokuapp.com/api/v1/datapoints?data_type=road-master&lat_start=34.66802946&lon_start=135.362425&lat_end=35.67436512&lon_end=140.2823427&offset=300&limit=300

Actuellement, seules les données de ligne rouge suivantes existent. 路面.png

Comme vous pouvez le voir en le développant, il semble que des données existent pour chaque voie.

路面2.png

Utilisé dans le langage de programmation

Python Ici, nous allons décrire comment obtenir l'état de la surface de la route en Python.

road_mgt.py


# -*- coding: utf-8 -*-
import urllib
import urllib2
from lxml import etree
import csv
from collections import defaultdict


def get_road_surface(offset, limit):
    """
Données sur l'état de la surface de la route
    """
    url = ('http://roadmgt.herokuapp.com/api/v1/datapoints?data_type=road-surface&offset=%d&limit=%d' % (offset, limit))

    req = urllib2.Request(url)
    opener = urllib2.build_opener()
    conn = opener.open(req)
    cont = conn.read()
    parser = etree.XMLParser(recover=True)
    root = etree.fromstring(cont, parser)
    namespaces = {
        'geo' : 'http://www.w3.org/2003/01/geo/wgs84_pos#',
        'rdf' : 'http://www.w3.org/1999/02/22-rdf-syntax-ns#', 
        'rdfs' : 'http://www.w3.org/2000/01/rdf-schema#', 
        'rm' : 'http://roadmgt.herokuapp.com/vocab/rm#'
    }

    row = []
    datas = {}
    value_tags = root.xpath('//rdf:Description', namespaces=namespaces)
    value_tags = root.xpath('//rdf:Description', namespaces=namespaces)
    for value_tag in value_tags:
        label = value_tag.find('rdfs:label', namespaces).text
        step = value_tag.find('rm:step', namespaces).text
        alt = value_tag.find('geo:alt', namespaces).text
        analysis_timestamp = value_tag.find('rm:analysis_timestamp', namespaces).text
        rutting_amount = value_tag.find('rm:rutting_amount', namespaces).text
        municipality_id = value_tag.find('rm:municipality_id', namespaces).text
        speed_fluctuation_flag = value_tag.find('rm:speed_fluctuation_flag', namespaces).text
        section_id = value_tag.find('rm:section_id', namespaces).text
        distance = value_tag.find('rm:distance', namespaces).text
        long = value_tag.find('geo:long', namespaces).text
        iri = value_tag.find('rm:iri', namespaces).text
        cracking_rate = value_tag.find('rm:cracking_rate', namespaces).text
        pothole_num = value_tag.find('rm:pothole_num', namespaces).text
        subsidence_and_puddle = value_tag.find('rm:subsidence_and_puddle', namespaces).text
        speed = value_tag.find('rm:speed', namespaces).text
        rms = value_tag.find('rm:rms', namespaces).text
        lat = value_tag.find('geo:lat', namespaces).text
        too_slow_fast_flag = value_tag.find('rm:too_slow_fast_flag', namespaces).text
        patching_num = value_tag.find('rm:patching_num', namespaces).text

        row.append({
            'label' : label,
            'step' : step,
            'alt' : alt,
            'analysis_timestamp' : analysis_timestamp,
            'rutting_amount' : rutting_amount,
            'municipality_id' : municipality_id,
            'speed_fluctuation_flag' : speed_fluctuation_flag,
            'section_id' : section_id,
            'distance' : distance,
            'long' : long,
            'iri' : iri,
            'cracking_rate' : cracking_rate,
            'pothole_num' : pothole_num,
            'subsidence_and_puddle' : subsidence_and_puddle,
            'speed' : speed,
            'rms' : rms,
            'lat' : lat,
            'too_slow_fast_flag' : too_slow_fast_flag,
            'patching_num' :patching_num
        })
    return row

def get_meas_locale(offset, limit):
    """
Données de position au moment de la mesure de la surface de la route
    """
    url = ('http://roadmgt.herokuapp.com/api/v1/datapoints?data_type=meas-locale&offset=%d&limit=%d' % (offset, limit))

    req = urllib2.Request(url)
    opener = urllib2.build_opener()
    conn = opener.open(req)
    cont = conn.read()
    parser = etree.XMLParser(recover=True)
    root = etree.fromstring(cont, parser)

    namespaces = {
        'geo' : 'http://www.w3.org/2003/01/geo/wgs84_pos#',
        'rdf' : 'http://www.w3.org/1999/02/22-rdf-syntax-ns#', 
        'rdfs' : 'http://www.w3.org/2000/01/rdf-schema#', 
        'rm' : 'http://roadmgt.herokuapp.com/vocab/rm#'
    }

    row = []
    datas = {}
    value_tags = root.xpath('//rdf:Description', namespaces=namespaces)
    for value_tag in value_tags:
        label = value_tag.find('rdfs:label', namespaces).text
        gpstimestamp = value_tag.find('rm:gpstimestamp', namespaces).text
        course = value_tag.find('rm:course', namespaces).text
        measurement_start_timestamp = value_tag.find('rm:measurement_start_timestamp', namespaces).text
        mounting_direction = value_tag.find('rm:mounting_direction', namespaces).text
        car_model = value_tag.find('rm:car_model', namespaces).text
        long = value_tag.find('geo:long', namespaces).text
        lat = value_tag.find('geo:lat', namespaces).text
        alt = value_tag.find('geo:alt', namespaces).text
        model_number = value_tag.find('rm:model_number', namespaces).text
        car_number = value_tag.find('rm:car_number', namespaces).text
        speed = value_tag.find('rm:speed', namespaces).text
        vertical_accuracy = value_tag.find('rm:vertical_accuracy', namespaces).text
        measurement_timestamp = value_tag.find('rm:measurement_timestamp', namespaces).text
        horizontal_accuracy = value_tag.find('rm:horizontal_accuracy', namespaces).text
        row.append({
            'label' : label,
            'gpstimestamp' : gpstimestamp,
            'course' : course,
            'measurement_start_timestamp' : measurement_start_timestamp,
            'mounting_direction' : mounting_direction,
            'car_model' : car_model,
            'long' : long,
            'lat' : lat,
            'alt' : alt,
            'model_number' : model_number,
            'car_number' : car_number,
            'speed' : speed,
            'vertical_accuracy' : vertical_accuracy,
            'measurement_timestamp' : measurement_timestamp,
            'horizontal_accuracy' : horizontal_accuracy
        })
    return row

def get_road_surface_all():
    ret = []
    limit = 300
    offset = 0
    try:
        while True:
            print ('get_road_surface_all %d' % offset)
            r = get_road_surface(offset, limit)
            ret.extend(r)
            offset += limit
    except urllib2.HTTPError, ex:
        if ex.code == 404:
            return ret
        else:
            raise

Vous pouvez obtenir toutes les conditions de surface de la route en utilisant get_road_surface_all (). En tant que programme, j'exécute simplement l'API avec urllib et analyse la réponse avec lxml.

JavaScript Ici, nous décrirons comment obtenir l'état de la surface de la route avec JavaScript.

  /**
   *Exécuter l'API des informations de surface de la route
   */
  function getDataByRange(data_type, lat_start, lon_start, lat_end, lon_end, callback) {
    var offset = 0;
    var limit = 300;
    var obj = {};

    function loadRoadOffset(lat_start, lon_start, lat_end, lon_end, offset, limit, obj, cb) {

      console.log(offset, limit);
      $.ajax({
        type : 'GET',
        url : 'http://roadmgt.herokuapp.com/api/v1/datapoints',
        cache: true , //,Une erreur se produit si le cache est défini sur false. Peut-être qu'au lieu d'ignorer des paramètres étranges, ils retournent
        data : {
          data_type : data_type,
          lat_start  : lat_start,
          lon_start : lon_start,
          lat_end  : lat_end,
          lon_end  : lon_end,
          offset : offset,
          limit : limit
        },
        success : function (data) {
          console.log(data);
          var root = data.documentElement;
          var attrs = root.attributes;
          var records = root.childNodes;
          for(var i=0; i<records.length; i++){
            if(records[i].nodeName.match(/rdf:Description/i)){
              var s = records[i].attributes["rdf:about"].value;
              var props = records[i].childNodes;
              for(var j=0; j<props.length; j++){
                if(props[j].nodeType == 1){
                  var p = props[j].nodeName;
                  var o = props[j].textContent;
                  if (!obj[s]) {
                    obj[s] = {};
                  }
                  if (obj[s][p]) {
                    if (!Array.isArray(obj[s][p])) {
                      var tmp = arys[s][p];
                      obj[s][p] = [];
                      obj[s][p].push(tmp);
                    }
                    obj[s][p].push(o);
                  } else {
                    obj[s][p] = o;
                  }
                }
              }
            }
          }
          loadRoadOffset(lat_start, lon_start, lat_end, lon_end, offset + limit, limit, obj, cb);
        },
        'error' :  function(xhr, textStatus, error) {
          console.log(xhr);
          var err = xhr.responseText;
          if (err == '404 notFound') {
            cb(null , obj);
          } else {
            cb(err , null);
          }
        }
      });
    }
    loadRoadOffset(lat_start, lon_start, lat_end, lon_end, offset, limit, obj, function(err, res) {
      callback(err, res);
    });
  }

Exécutez cette fonction comme suit:

getDataByRange('road-master', surfaceRange.lat_min, surfaceRange.long_min, surfaceRange.lat_max, surfaceRange.long_max, function(err, data) {
      console.log('loadRoad', err, data);
});

Ce processus obtient toutes les données de spécification de route dans la plage spécifiée.

Résumé

Vous pouvez obtenir l'état de la surface de la route en exécutant l'API «Expérience de démonstration dans la gestion avancée de la surface de la route».

Cela permet de visualiser l'état de détérioration des routes.

Recommended Posts

Essayez d'obtenir l'état de la surface de la route en utilisant de grandes données de gestion de la surface de la route
Essayez d'obtenir le contenu de Word avec Golang
Essayez d'obtenir la liste des fonctions du paquet Python> os
Essayez d'extraire les caractéristiques des données de capteur avec CNN
Essayez d'obtenir des statistiques en utilisant e-Stat
J'ai essayé d'obtenir l'index de la liste en utilisant la fonction énumérer
Obtenez la liste des colonnes et la liste des données de CASTable
Essayez d'imaginer les données d'élévation du National Land Research Institute avec Python
Essayez d'utiliser n pour rétrograder la version de Node.js que vous avez installée
Essayez de prédire la valeur de la jauge de niveau d'eau par apprentissage automatique en utilisant les données ouvertes de Data City Sabae
Essayez d'utiliser django-import-export pour ajouter des données csv à django
Jusqu'à ce que vous essayiez de laisser DNN apprendre la vérité de l'image en utilisant Colab
Comment obtenir des données d'article à l'aide de l'API Qiita
Je veux obtenir les données de League of Legends ③
Je veux obtenir les données de League of Legends ②
Essayez d'utiliser le module de collections (ChainMap) de python3
Une introduction à l'analyse de données à l'aide de Python - Pour augmenter le nombre de vues vidéo -
Essayez d'afficher les données ferroviaires des informations numériques des terres nationales en 3D
Je veux obtenir les données de League of Legends ①
Essayez de simuler le mouvement du système solaire
Vérifiez l'état des données à l'aide de pandas_profiling
Gratter les données gagnantes de Numbers à l'aide de Docker
[Introduction à Python] Comment obtenir l'index des données avec l'instruction for
Je souhaite obtenir des attributs de données personnalisés de HTML sous forme d'éléments à l'aide de Python Selenium
Essayez de créer une table d'enregistrement de bataille avec matplotlib à partir des données de "Schedule-kun"
Donnez les données de séquence de points de latitude et de longitude et essayez d'identifier la route à partir des données d'OpenStreetMap
Comment obtenir le nombre de chiffres en Python
Essayez de résoudre les problèmes / problèmes du "programmeur matriciel" (Chapitre 1)
Analyse de Big Data à l'aide du framework de contrôle de flux de données Luigi
Essayez d'estimer le nombre de likes sur Twitter
Écrire des données dans KINTONE à l'aide du module de requêtes Python
J'ai essayé d'utiliser l'API de Sakenowa Data Project
Essayez de déchiffrer les données de connexion stockées dans Firefox
Script pour obtenir la date d'expiration du certificat SSL
L'histoire de l'utilisation de Circleci pour construire des roues Manylinux
La route vers Pythonista
La route vers Djangoist
[Question] Comment obtenir les données des données textarea en temps réel à l'aide du flacon du framework Web Python
Comment obtenir uniquement les données nécessaires du groupe de données structurées à l'aide d'une méthode polyvalente
Essayez de gratter les données COVID-19 Tokyo avec Python
J'ai essayé d'obtenir les informations de localisation du bus Odakyu
Obtenez des données à l'aide de l'API du ministère des Affaires intérieures et des Communications
Essayez d'évaluer les performances du modèle d'apprentissage automatique / de classification
Je veux obtenir des informations sur le fonctionnement de Yahoo Route
Essayez d'améliorer la précision de l'estimation du nombre de Twitter
Essayez de résoudre les problèmes / problèmes du "programmeur matriciel" (fonction du chapitre 0)
Essayez d'automatiser le fonctionnement des périphériques réseau avec Python
Afficher le contenu de la file d'attente à l'aide de l'API Web de gestion RabbitMQ
L'histoire de la copie de données de S3 vers TeamDrive de Google
Essayez d'acquérir des données lors de la redirection de port vers RDS avec anaconda.
[Python] J'ai essayé de collecter des données en utilisant l'API de wikipedia
Essayez de modéliser une distribution multimodale à l'aide de l'algorithme EM
Keras Je veux obtenir la sortie de n'importe quelle couche !!
Comment obtenir un aperçu de vos données dans Pandas
[Introduction à Python] Comment obtenir des données avec la fonction listdir
Pour obtenir le nom de la primitive etc. généré immédiatement avant
Récupérez la source de la page à charger indéfiniment avec python.
J'ai essayé d'obtenir rapidement des données d'AS / 400 en utilisant pypyodbc
J'ai envoyé les données de Raspberry Pi à GCP (gratuit)