Cet article est un article du 17 décembre de "Oracle Cloud Infrastructure Advent Calendar 2019" Il s'écrit 2019-12-17).

Ce que vous faites dans cet article

--Création d'une instance VCN / Compute / Autonomous Database (ADW) dans un environnement Always Free d'Oracle Cloud Infrastructure --Configurez un environnement Jupyter Notebook sur votre instance Compute

Apprentissage automatique en utilisant les données de la base de données autonome (arbre de décision / forêt aléatoire)

Procédure de construction de l'environnement

Créez un réseau cloud virtuel
Créez une instance de calcul
Créez une base de données autonome (ADW cette fois)![Image01.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/108635/5a0120bc-05c4-6f3a- e99a-3e873a044f1e.jpeg)
Configuration de l'environnement Jupyter Notebook sur l'instance Compute
Connectez-vous à la base de données autonome à partir de Jupyter Notebook et effectuez un apprentissage automatique

1. Créez un réseau cloud virtuel

Créer un réseau cloud virtuel (VCN) dans la console Web OCI Le démarrage rapide du réseau virtuel a été ajouté depuis le 5 décembre 2019 Vous pouvez facilement créer un VCN avec quatre éléments d'entrée: "VCN name", "VCN CIDR", "public subnet CIDR" et "private subnet CIDR". (Lors de la création d'un VCN à l'aide de Quickstart, si vous le créez en affichage japonais, le nom du sous-réseau sera quelque chose comme "Sous-réseau public- " Il est recommandé de changer la langue d'affichage en anglais)

Un environnement Always Free peut être créé dans la région d'origine

2. Créez une instance de calcul

Créer une instance Compute avec une image d'Oracle Linux 7

Cliquez sur «Afficher la forme, le réseau et les options de stockage» et dans la configuration réseau, 1. Sélectionnez le réseau cloud virtuel et le sous-réseau public créés dans
De plus, cochez "Attribuer une adresse IP publique" et créez

3. Création d'une base de données autonome (ADW cette fois)

Créez un type de charge de travail à partir de Créer une base de données autonome en sélectionnant Entrepôt de données

Créez un utilisateur actif à l'aide de SQL Developer Web, etc.

CREATE USER scott IDENTIFIED BY password; 

GRANT DWROLE TO scott;
GRANT UNLIMITED TABLESPACE TO scott;

GRANT
    SELECT ANY TABLE,
    UPDATE ANY TABLE,
    DELETE ANY TABLE,
    INSERT ANY TABLE
TO scott;

4. Configuration de l'environnement Jupyter Notebook sur l'instance Compute

Connectez-vous à l'instance Compute (Oracle Linux) créée en 2. avec ssh (utilisateur opc) et installez Jupyter Notebook

4-1. Installez Python 3 4-1-1. Dépôt EPEL - Installation de Python3.6

sudo yum install -y oracle-epel-release-el7 oracle-release-el7
sudo yum install -y python36
sudo yum install -y libSM.x86_64
sudo yum install -y libXext.x86_64
sudo yum install -y libXrender.x86_64

4-1-2. Mlevn (configuration / activation de l'environnement virtuel Python)

python3.6 -m venv mlenv 
source mlenv/bin/activate

4-1-3. Installer la bibliothèque utilisée pour l'apprentissage automatique (bibliothèque pour l'exécution de cette procédure)

pip3 install --upgrade pip
pip3 install pandas
pip3 install seaborn
pip3 install sklearn

4-1-4. Installez Jupyter

python3 -m pip install jupyter

4-1-5. Installation et configuration d'Oracle Instant Client

sudo yum -y install oraclelinux-developer-release-el7
sudo yum -y install python-cx_Oracle
pip3 install cx_Oracle
sudo sh -c "echo /usr/lib/oracle/18.3/client64/lib > /etc/ld.so.conf.d/oracle-instantclient.conf"
sudo ldconfig

4-1-6. Téléchargement des informations d'identification du client de base de données autonome (portefeuille) Depuis l'écran de détails de la base de données autonome créée en 3., cliquez sur "Connexion à la base de données", puis sur "Télécharger le portefeuille" dans la boîte de dialogue "Connexion à la base de données" pour télécharger le fichier Zip. Transférez le fichier Zip téléchargé vers une instance Compute (telle que scp) et décompressez-le (notez le répertoire décompressé Exemple: / home / opc / wallet) Modifiez le fichier sqlnet.ora dans le répertoire décompressé Remplacez "~ / network / admin" spécifié dans DIRECTORY sur la ligne "WALLET_LOCATION" par le répertoire décompressé.

`sqlnet.ora`


WALLET_LOCATION = (SOURCE = (METHOD = file) (METHOD_DATA = (DIRECTORY="/home/opc/wallet")))
SSL_SERVER_DN_MATCH=yes

4-1-7. Exécuter Notebook Définir les variables d'environnement (LD_LIBRARY_PATH est le chemin du client d'instance, TNS_ADMIN est le répertoire dans lequel le portefeuille a été décompressé)

export LD_LIBRARY_PATH=/usr/lib/oracle/18.3/client64/lib:$LD_LIBRARY_PATH
export TNS_ADMIN=/home/opc/wallet
source mlenv/bin/activate
jupyter notebook --ip=0.0.0.0 &

Notez la clé de jeton qui apparaît lorsque vous exécutez le notebook Jupyter

    To access the notebook, open this file in a browser:
        file:///home/opc/.local/share/jupyter/runtime/nbserver-2210-open.html
    Or copy and paste one of these URLs:
        http://compute01:8888/?token=0e701120a4e7319ae8b970ac069fbfee53e7b07f072cc2dc
     or http://127.0.0.1:8888/?token=0e701120a4e7319ae8b970ac069fbfee53e7b07f072cc2dc     ```

5.Connectez-vous à la base de données autonome à partir de Jupyter Notebook et effectuez un apprentissage automatique

5-1.Établir un tunnel à partir du PC client dans une autre session ssh

`$ ssh –i <private_key> opc@<public_IP_address> -L 8000:localhost:8888`


5-2.Ouvrez un navigateur Web sur votre ordinateur local et accédez à l'URL suivante
http://localhost:8000 
5-3.Lorsque vous êtes invité à entrer un jeton, entrez la clé de jeton qui apparaît lorsque vous exécutez le notebook jupyter
![image06.JPG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/108635/bbf7a0a4-64f7-a9a5-0a5f-1ed216b319c3.jpeg)

![image07.JPG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/108635/b1949454-7e7c-4cd5-4d61-fc0e5c6bfb37.jpeg)

5-4.Connectez-vous à la base de données autonome depuis Jupyter Notebook
Nom d'utilisateur, mot de passe et tnsnames de la base de données autonome dans le portefeuille décompressé.Vérifiez le nom du service de connexion depuis ora et spécifiez

Exemple de connexion à la base de données autonome et vérification de la version de la base de données

import cx_Oracle con = cx_Oracle.connect('scott/@orcl_medium') print(con.version) con.close()


Exemple de connexion à la base de données autonome et vérification du nombre de tables SALES dans le schéma sh

import cx_Oracle con = cx_Oracle.connect('scott/@orcl_medium') cur = con.cursor() # opens cursor for statements to use cur.execute('select count(*) from sh.sales') for result in cur: # prints all data print(result) con.close()


CUST par sexe du tableau CLIENTS_Comparez VALID

import pandas.io.sql as psql import cx_Oracle import seaborn as sns %matplotlib inline

con = cx_Oracle.connect('scott/@orcl_medium')

sql = 'select CUST_GENDER,CUST_VALID from sh.customers' df = psql.read_sql(sql,con) sns.countplot('CUST_GENDER',hue='CUST_VALID',data=df)

Les noms de colonnes sont écrits en majuscules

con.close()


![image08.JPG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/108635/b0fd0ce8-514a-d38e-c19e-ca4228e4cd5a.jpeg)



####Apprentissage automatique
scikit-Arborescence de la bibliothèque et scikit dans Learn-Utilisation du fier de classe de forêt aléatoire dans l'ensemble d'apprentissage
CUST dans le tableau CUSTOMERS_Créez un modèle d'apprentissage automatique qui prédit VALIDE

-Obtenez des fonctionnalités et des variables objectives avec l'instruction SELECT et stockez-les dans DataFrame

sql = 'select cust_id,cust_year_of_birth,CUST_GENDER,cust_postal_code,cust_valid from sh.customers' df = psql.read_sql(sql,con)


-Gestion des valeurs manquantes et variables catégorielles(lettre)Processus de conversion

Traitement de la valeur manquante

df['CUST_YEAR_OF_BIRTH'] = df['CUST_YEAR_OF_BIRTH'].fillna(df['CUST_YEAR_OF_BIRTH'].median()) df['CUST_POSTAL_CODE'] = df['CUST_POSTAL_CODE'].fillna(df['CUST_POSTAL_CODE'].median())

Conversion de variables catégorielles

df['CUST_VALID']=df['CUST_VALID'].apply(lambda x:1 if x == 'I' else 0) df['CUST_GENDER']=df['CUST_GENDER'].apply(lambda x:1 if x == 'M' else 0)


-Divisé en données d'entraînement et données de test(Cette fois, 90% sont utilisés comme données d'entraînement)

X = df.loc[:, ["CUST_YEAR_OF_BIRTH","CUST_GENDER","CUST_POSTAL_CODE"]] Y = df.loc[:, "CUST_VALID"] (train_X, test_X ,train_y, test_y) = train_test_split(X, Y, test_size = 0.1, random_state = 666)


-Création du modèle d'arbre de décision, vérification avec données de test, confirmation de l'exactitude

clf = DecisionTreeClassifier(random_state=0) clf = clf.fit (train_X, train_y) #Créez un modèle! pred = clf.predict(test_X) print("Prediction Score: {}".format(clf.score(test_X, test_y)))


-Création et validation de modèles de forêts aléatoires avec des données de test

from sklearn.ensemble import RandomForestClassifier clf = RandomForestClassifier(random_state=0) clf = clf.fit(train_X, train_y) pred = clf.predict(test_X)


-Code d'apprentissage automatique complet


#### **`ml4py.py`**
```py

import pandas.io.sql as psql
import cx_Oracle
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import (roc_curve, auc, accuracy_score)
from sklearn.metrics import classification_report
con = cx_Oracle.connect('scott/<password>@orcl_medium')

sql = 'select cust_id,cust_year_of_birth,CUST_GENDER,cust_postal_code,cust_valid from sh.customers'
df = psql.read_sql(sql,con)
# Traitement de la valeur manquante
df['CUST_YEAR_OF_BIRTH'] = df['CUST_YEAR_OF_BIRTH'].fillna(df['CUST_YEAR_OF_BIRTH'].median())
df['CUST_POSTAL_CODE'] = df['CUST_POSTAL_CODE'].fillna(df['CUST_POSTAL_CODE'].median())

# Conversion de variables catégorielles
df['CUST_VALID']=df['CUST_VALID'].apply(lambda x:1 if x == 'I' else 0)
df['CUST_GENDER']=df['CUST_GENDER'].apply(lambda x:1 if x == 'M' else 0)

X = df.loc[:, ["CUST_YEAR_OF_BIRTH","CUST_GENDER","CUST_POSTAL_CODE"]]
Y = df.loc[:, "CUST_VALID"]
(train_X, test_X ,train_y, test_y) = train_test_split(X, Y, test_size = 0.1, random_state = 666)

clf = DecisionTreeClassifier(random_state=0)
 clf = clf.fit (train_X, train_y) #Créez un modèle!
pred = clf.predict(test_X)
fpr, tpr, thresholds = roc_curve(test_y, pred, pos_label=1)
auc(fpr, tpr)
accuracy_score(pred, test_y)
classification_report(pred, test_y, labels=None)
print("Prediction Score: {}".format(clf.score(test_X, test_y)))
 print ("Précision du modèle d'arbre de décision: {: .6f}". format (precision_score (pred, test_y)))

from sklearn.ensemble import RandomForestClassifier
clf = RandomForestClassifier(random_state=0)
clf = clf.fit(train_X, train_y)
pred = clf.predict(test_X)
fpr, tpr, thresholds = roc_curve(test_y, pred, pos_label=1)
auc(fpr, tpr)
 print ("Précision du modèle de forêt aléatoire: {: .6f}". format (precision_score (pred, test_y)))
con.close()

##Résumé et pour l'avenir Environnement toujours libre(Instance de calcul et base de données autonome)Apprentissage automatique avec Jupyter Notebook en utilisant(Arbre de décision / forêt aléatoire)A pu être réalisé.

Datée du 5 décembre 2019Les fonctionnalités d'apprentissage automatique, de données géographiques et d'analyse de données graphiques dans Oracle Database ne sont plus des options payantes et sont désormais disponibles dans Standard Edition. L'API Oracle Machine Learning pour Python estcoming soonParce que ça veut dire J'aimerais pouvoir comparer la date de sortie d'Oralce Machine Learning pour Python.

###Informations de référence

[PYTHON] Apprentissage automatique à l'aide de Jupyter Notebook dans l'environnement OCI Always Free (2019/12/17)