[Super Introduction] Apprentissage automatique utilisant Python - De la construction d'environnement à l'implémentation de perceptron simple-

Tout d'abord

Cet article est un article du ** DMM WEBCAMP Advent Calendar Day 7 **. Cette fois, c'est une édition super introductive, donc je l'ai créée pour ** les personnes qui n'ont jamais fait de machine learning mais qui veulent commencer **.

** Le but est de se faire une idée approximative de l'apprentissage automatique et d'essayer d'implémenter un perceptron simple de base **, j'ai donc beaucoup écrit sur l'explication de l'apprentissage automatique, etc. (si vous écrivez chacun correctement) Ce sera incroyablement long). Si vous souhaitez en savoir plus, consultez-le.

De plus, cette fois, nous introduisons la construction d'environnement sur Windows 10. S'il y a des parties qui sont difficiles à transmettre ou qui sont reconnues par erreur dans le premier message de Qiita, j'apprécierais que vous puissiez les signaler dans les commentaires.

Overview Une explication approximative de l'apprentissage automatique Installation de Python Installation de Miniconda Implémentation de Simple Perceptron (Neural Network)

Une explication approximative de l'apprentissage automatique

Qu'est-ce que l'apprentissage automatique?

Supposons qu'une personne venant de l'avant emmène un animal en promenade. Je pense que vous jugez principalement visuellement ce qu'est l'animal (chien ou chat?) Et quel genre de chien ou de chat il s'agit. Un autre suppose que vous entendez un son du type "clic, clic, clic ...". Je pense que vous jugez principalement si le son que vous entendez est le bruit des pas, le bruit des applaudissements ou le son des aiguilles de l'horloge. De cette manière, les êtres humains prennent des décisions basées sur leur expérience dans leur vie quotidienne.

Il existe un apprentissage automatique pour en faire également un ordinateur. En laissant l'ordinateur itérer et prendre des décisions avec une grande précision, il devient possible de prédire les résultats pour des données inconnues.

Types d'apprentissage automatique

Les méthodes d'apprentissage automatique peuvent être globalement divisées en deux types: ** apprentissage automatique non supervisé ** et apprentissage automatique ** supervisé **.

Apprentissage automatique sans enseignant

La plus grande différence par rapport à l'apprentissage automatique supervisé est qu'il n'y a pas de données de réponse correctes. S'il y a 1 000 données, toutes seront traitées comme des données d'entraînement. Il est principalement groupé et groupé en fonction de caractéristiques communes. La méthode d'implémentation la plus connue est la ** méthode K-Means **. Je ne parlerai plus de l'apprentissage automatique sans enseignant, mais si vous êtes intéressé, veuillez le vérifier.

Apprentissage automatique supervisé

Contrairement à l'apprentissage automatique sans enseignant, il s'agit d'une méthode d'apprentissage avec des données de réponse correctes. De même, en supposant qu'il y a 1000 éléments de données, par exemple, 700 éléments sont divisés en données d'apprentissage et 300 éléments sont des données de réponse correcte, et l'apprentissage est répété. Parmi eux, je parlerai cette fois des réseaux de neurones et du deep learning.

réseau neuronal

Il s'agit d'une méthode d'apprentissage basée sur un modèle de cellules nerveuses du cerveau humain. Plusieurs cellules nerveuses sont connectées, reçoivent une entrée de la synapse de la cellule nerveuse adjacente et transmettent des informations à la cellule nerveuse adjacente. De cette manière, le réseau neuronal est divisé en une couche d'entrée et une couche de sortie, et lorsque le poids total des couches d'entrée dépasse un certain niveau, une valeur est entrée dans la couche de sortie. Cette fois, nous allons créer un programme qui implémente ce réseau de neurones.

L'apprentissage en profondeur

En gros, l'apprentissage en profondeur est compliqué en incorporant un réseau neuronal en plusieurs couches. Comparé à l'apprentissage automatique dans l'article ** DMM WEBCAMP Advent Calendar ** de l'année dernière "Pour les super débutants. Différences entre l'apprentissage en profondeur et l'apprentissage automatique" Il a été écrit sur l'apprentissage en profondeur, veuillez donc vous y référer également.

Une explication approximative a continué, mais c'est tout pour l'explication. Pourriez-vous comprendre à quoi ressemble l'apprentissage automatique? Maintenant, créons un environnement pour l'apprentissage automatique.

Installation de Python

Après tout, la première chose à faire est d'installer Python.

Vérification de la version Windows

Et avant cela, assurez-vous de disposer de la dernière version de Windows. La dernière version en décembre 2019 est la ** Version 1909 **. S'il ne s'agit pas de la dernière version, nous vous recommandons de passer à la dernière version.

Installation de Python

Allez sur https://www.python.org et allez sur ** Télécharger ** au milieu de la page que vous avez visitée Dernière: ** Python (* Vision *) )**Cliquez sur. La dernière version de Python en décembre 2019 est ** Python 3.8.0 **.

Cliquez sur ** Programme d'installation exécutable Windows x86-64 ** à partir de ** Fichiers ** au bas de la page de destination pour télécharger le programme d'installation Python.

Lancez le programme d'installation téléchargé et vérifiez ** ajouter Python (* Virsion *) à PATH ** avant de démarrer l'installation. Cela vous permettra de lancer Python sur l'invite de commande. Si vous n'en avez pas besoin, démarrez l'installation sans la vérifier.

Si vous voyez ** désactiver la limite de longueur de chemin ** sur cette page vous notifiant que l'installation est terminée, vous pouvez le sélectionner pour supprimer la limite de longueur de chemin de fichier. L'image n'est pas visible car elle a été levée lors de l'installation précédente de Python.

Ceci termine l'installation de Python. Vous pouvez taper ** IDLE ** dans le menu de démarrage de Windows et entrer le code dans le programme sélectionné et démarré. Il est donc facile d'écrire des programmes Python sans un éditeur de texte comme Sublime Text 3 ou Visual Stdio Code.

** Si vous n'avez jamais écrit de programme Python **, c'est une bonne idée de le toucher un peu avant d'implémenter Simple Perceptron. Si vous êtes un écrivain régulier de C ou Java, vous pouvez exprimer ce que vous voulez faire avec un peu de description, afin de pouvoir le comprendre facilement.

Installation de Miniconda

Qu'est-ce que Miniconda

Miniconda est l'un des systèmes fournis par un système de gestion open source appelé ** Conda **. Il y en a un autre appelé ** Anaconda ** qui est similaire à Miniconda, mais c'est fondamentalement le même, et comme l'installation d'Anaconda nécessite un fichier assez volumineux, seules les fonctions minimales requises sont requises. C'est Miniconda. Il ressemble à ** Anaconda ⊆ Miniconda **.

L'analyse des données peut être effectuée plus facilement en utilisant Python + Miniconda.

Installation de Miniconda

Accédez à la documentation Miniconda - Conda (https://docs.conda.io/en/latest/miniconda.html) et téléchargez le programme d'installation de Miniconda. À partir de ** Windows installer **, sélectionnez et téléchargez la dernière version de Python ** Miniconda3 Windows 64 bits **. Je n'ai pas Python 3.8 Miniconda cette fois, mais Python 3.7 Miniconda est très bien.

Lancez le programme d'installation téléchargé, sélectionnez Suivant-> J'accepte, assurez-vous que le bouton radio ** Just Me (recommandé) ** est sélectionné avant de continuer.

Il est recommandé de passer à l'écran suivant sans apporter de modifications, car changer le ** Dossier de destination ** qui apparaît sur l'écran suivant peut être un problème.

Sur l'écran ** Options d'installation avancées **, fixez la version Python par défaut à 3.7, décochez ** Enregistrer Aaconda comme mon Python 3.7 par défaut ** et démarrez l'installation à partir de **.

Sur cet écran qui apparaît une fois l'installation terminée, décochez les deux avant de quitter le programme d'installation.

Construire un environnement virtuel

Lançons Anaconda Prompt à partir du bouton de démarrage de Windows. J'ai installé Miniconda, mais comme mentionné précédemment, parmi Anaconda, Miniconda n'a que les fonctions minimales, donc la notation est Anaconda. Entrez la commande suivante pour poursuivre la construction de l'environnement.

Mise à jour du conda installé

conda update conda -y

AnacondaPrompt

>conda update conda -y
Collecting package metadata (current_repodata.json): done
Solving environment: done

# All requested packages already installed.

Si ça sort comme ça, il n'y a pas de problème.

Depuis décembre 2019, il n'y a pas de Miniconda qui prend en charge Python 3.8, donc Anaconda Prompt prend en charge Python dans la version 3.7. Cependant, il n'y a presque aucun problème. Vous pouvez le vérifier avec conda list.

AnacondaPrompt

>conda list
# packages in environment at C:\Users\Nom d'utilisateur\Miniconda3:
#
# Name                    Version                   Build  Channel
asn1crypto                1.2.0                    py37_0
ca-certificates           2019.11.27                    0
･ ･ ･
python                    3.7.4                h5263a28_0

Créer un environnement virtuel

Le nom de l'environnement est gratuit, mais cette fois nous allons procéder avec ** NN_sample **. Afin d'éliminer le problème causé par la différence de version causée par l'installation de Python 3.8, spécifiez la version Python à 3.7.4 et créez un environnement virtuel. Pour ** Continuer ([y] / n)? ** qui apparaît en chemin, entrez ** y ** et appuyez sur Entrée.

conda create -n NN_sample python=3.7.4

AnacondaPrompt

>conda create -n NN_sample python=3.7.4
Collecting package metadata (current_repodata.json): done
Solving environment: done

## Package Plan ##

  environment location: C:\Users\Nom d'utilisateur\Miniconda3\envs\NN_sample



Proceed ([y]/n)? y

Preparing transaction: done
Verifying transaction: done
Executing transaction: done
#
# To activate this environment, use
#
#     $ conda activate NN_sample
#
# To deactivate an active environment, use
#
#     $ conda deactivate

Démarrez l'environnement virtuel. Il peut être activé avec ʻactiver le nom d'environnement`. Si le démarrage réussit, ** (base) ** deviendra ** (nom de l'environnement) **.

AnacomdaPrompt

(base) C:\Users\Nom d'utilisateur>activate NN_sample
(NN_sample) C:\Users\Nom d'utilisateur>

Ajouter les bibliothèques requises

Nous ajouterons les bibliothèques nécessaires dans l'environnement virtuel pour que #include <~ .h> en C et ʻimport java.io. ~ `En Java puisse être fait. Veuillez poursuivre avec l'environnement virtuel démarré. Les 5 suivants sont installés cette fois.

• Jupyter Lab
• NumPy
• matplotlib
• TensorFlow
• Keras

** jupyter lab ** n'est pas une bibliothèque, mais un éditeur de texte, comme un outil Web qui vous permet de coder tout en vérifiant les données, contrairement aux autres que vous installez cette fois. Auparavant, ** jupyter notebook ** était le plus courant, mais de nos jours, c'est une image de l'utilisation de jupyter lab. Entrez la commande suivante pour installer jupyter lab.

AnacondaPrompt

>conda install -c conda-forge jupyterlab

Nous installerons les bibliothèques nécessaires. Je n'entrerai pas dans la description de chaque bibliothèque, mais au minimum, elles sont toutes nécessaires pour implémenter un simple Perceptron.

AnacondaPrompt

>conda install numpy matplotlib tensorflow keras

Il existe de nombreuses autres bibliothèques, et je n'en écrirai que quelques-unes que j'utiliserai pour tout apprentissage automatique à l'avenir.

• Python Imaging Library
• SciPy
• pandas
• NetWorkX (algorithmes graphiques plutôt que machine learning)

C'est tout pour construire l'environnement, y compris l'environnement virtuel.

Implémentation de Simple Perceptron

Je suis enfin là. Nous allons créer un programme qui implémente Simple Perceptron dans jupyter lab. Avant cela, jetons un coup d'œil au Simple Perceptron.

Qu'est-ce que Simple Perceptron?

Comme mentionné précédemment, un simple perceptron est un type de réseau neuronal. Par conséquent, il est divisé en une couche d'entrée et une couche de sortie, et lorsque le total des couches d'entrée dépasse une certaine valeur, les informations sont transmises à la couche de sortie. Un perceptron simple a ** plusieurs entrées et une seule sortie **. Si les poids de chaque couche d'entrée sont W1, W2, ..., Wx et que les poids non liés à la couche d'entrée sont θ, la somme du produit de chaque valeur d'entrée et du poids et de la somme de θ est supérieure à 0. Sorties 1, sinon 0. Si vous l'écrivez dans un modèle, ce sera comme suit. Si vous l'écrivez dans une formule mathématique,

N₁ × W₁ + N₂ × W₂ + ... + Nx × Wx + θ > 0 

Ce sera. De plus, si vous organisez le côté gauche,

\frac{N₁}{N₂} × W₁ + W₂ + \frac{θ}{N₂} = 0 \\
W₂ = (- \frac{N₁}{N₂}) × W₁ + (- \frac{θ}{N₂})

C'est difficile à comprendre, donc si vous changez la variable

y = a × x + b

Vous pouvez voir que c'est une ligne droite. En d'autres termes, avec le perceptron simple, vous pouvez tracer une ligne droite qui divise la valeur d'entrée et la valeur de sortie en deux, comme indiqué ci-dessous.

C'est une explication approximative du Simple Perceptron. Pourriez-vous comprendre cela aussi? Cette fois, nous allons créer un programme qui se divise en deux pour la fonction ** AND ** à deux entrées. La fonction ET produit 1 si les deux entrées sont 1 et 0 dans le cas contraire. Par conséquent, la division est prévue comme suit.

Préparation préalable

Utilisez la ** commande cd ** pour accéder au dossier de travail, puis démarrez jupyter lab. Cette fois, nous le ferons sous Documents / échantillon.

AnacondaPrompt

(base) C:\Users\Nom d'utilisateur>cd Documents

#Créer un dossier d'exemple
(base) C:\Users\Nom d'utilisateur\Documents>mkdir sample

(base) C:\Users\Nom d'utilisateur\Documents>cd sample

(base) C:\Users\Nom d'utilisateur\Documents\sample>activate NN_sample

(NN_sample) C:\Users\Nom d'utilisateur\Documents\sample>

Lancez Jupyter Lab

Pour jupyter lab, tapez simplement jupyter lab pour démarrer jupyter lab et lancer le navigateur Web. S'il ne démarre pas, après avoir exécuté jupyter lab, copiez l'URL écrite à la fin de la phrase qui apparaît et accédez-y avec un navigateur.

AnacondaPrompt

(NN_sample) C:\Users\Nom d'utilisateur\Documents\Nom de dossier>jupyter lab
[I 20:43:50.910 LabApp] JupyterLab extension loaded from C:\Users\Nom d'utilisateur\Miniconda3\envs\Nom de l'environnement\lib\site-packages\jupyterlab
･ ･ ･
    Or copy and paste one of these URLs:
        http://localhost:8888/?token=43ed3a669bd4da587fa6febf75f3e38b0f7de64916e96648
     or http://127.0.0.1:8888/?token=43ed3a669bd4da587fa6febf75f3e38b0f7de64916e96648

Créer un cahier

La façon dont vous le créez n'a pas d'importance, mais en haut à gauche du laboratoire jupyter, sélectionnez * Fichier-> Nouveau-> Bloc-notes * pour créer un nouveau bloc-notes. Le ** Select Kernel ** qui apparaît après la sélection peut être laissé comme ** python 3 **.

Dans le bloc-notes créé, le code est divisé en cellules et vous pouvez sélectionner du code, Markdown et Raw pour chaque cellule. Si vous pouvez diviser correctement les cellules, vous ne pouvez exécuter que la partie nécessaire du programme. Vous pouvez exécuter chaque cellule en appuyant sur Maj + Entrée.

Création de code

Importer les bibliothèques requises

Tout d'abord, installez les bibliothèques nécessaires. Décrivez avec ʻimporter le nom de la bibliothèque ou ʻimporter le nom de la bibliothèque comme nom utilisé dans le programme.

sample.ipynb

import numpy as np
import matplotlib.pyplot as plt
import os
import csv
from keras.models import Sequential
from keras.layers import Dense, Activation

Définition des variables d'environnement

Les variables utilisées dans le code sont définies ici. Cette fois, c'est un code court, mais surtout dans l'apprentissage automatique, il existe de nombreuses possibilités de modifier le nombre d'apprentissage et le fichier spécifié, donc si vous le définissez à la fois et modifiez cette cellule, vous pouvez l'appliquer à tout dans le programme.

sample.ipynb

CSVFILE = 'data.csv'
GRIDFILE = 'grid.csv'
header = ['x', 'y', 'class']
body = [
    [0, 0, 0],
    [1, 0, 0],
    [0, 1, 0],
    [1, 1, 1]
]

Créer un fichier csv

Nous écrirons la fonction Add, qui sera le modèle plus tard, dans le fichier csv. Il crée également un fichier csv pour créer la grille nécessaire pour dessiner le graphe entraîné. Ce n'est pas une partie essentielle, donc vous pouvez l'ignorer. Comme vous n'avez besoin que de créer un fichier csv, vous ne pouvez exécuter cette cellule qu'une seule fois.

sample.ipynb

#Supprimer tout fichier csv nommé CSVFILE
if os.path.exists(CSVFILE):
    os.unlink(CSVFILE)
if os.path.exists(GRIDFILE):
    os.unlink(GRIDFILE)

#Écrire dans un fichier
# with open(Nom de fichier que vous souhaitez gérer,mode(w:l'écriture))comme nom de variable:
with open(CSVFILE, 'w') as v:
    writer = csv.writer(v)
    writer.writerow(header)
    writer.writerows(body)

with open(GRIDFILE, 'w') as v:
    x = float(0)
    y = float(0)
    writer = csv.writer(v)
    writer.writerow([x, y])
    pre_x = x
    pre_y = y
    for _ in range(0, 20):
        pre_y += 0.05
        writer.writerow([round(pre_x, 4), round(pre_y, 4)])
    for _ in range(0, 20):
        pre_y = y
        pre_x += 0.05 
        for _ in range(0, 21):
            writer.writerow([round(pre_x, 4), round(pre_y, 4)])
            pre_y += 0.05

Lire le fichier csv

Extrayez le fichier csv avec les données nécessaires à la formation. Extraire à l'aide de la ** tranche ** unique de python. En plus du slicing, il est également possible d'extraire en tant que ** type Dataflame ** en utilisant ** pandas **, mais cette fois nous avons besoin du type ndarray, nous allons donc extraire par slicing. Les tranches ont encore plus d'éléments à connaître, veuillez donc vous référer à ici pour en savoir plus.

sample.ipynb

#Ignorez la première ligne de CSVFILE,','Séparé par, stocké dans des données variables en tant que type ndarray
data = np.loadtxt(CSVFILE, delimiter=',', skiprows=1)

#Extraire des données autres que la dernière colonne
ip_train = data[:, :-1]
# [[0. 0.]
#  [1. 0.]
#  [0. 1.]
#  [1. 1.]]

#Extraire la dernière colonne de données
class_train = data[:, -1]
# [0. 0. 0. 1.]

Exécution de l'apprentissage

Si un avertissement apparaît, il n'y a pas de problème, mais veuillez réessayer.

• Sequential()

Générez un constructeur pour l'apprentissage. Par conséquent, vous pouvez ajouter des couches avec la variable .add (...) qui stocke Sequential (). Bien sûr, vous pouvez également écrire des couches à la fois, telles que Séquentiel ([Dense (...), Activation (...)]).

• add(Dense(...))

Comme mentionné précédemment, nous ajouterons des couches au constructeur pour l'apprentissage. Cette fois, la fonction d'activation est sigmoïde, le nombre de neurones est de 1 et la valeur d'entrée est de 2. Dans ce cas, la fonction d'activation détermine comment * N₁ × W₁ + N₂ × W₂ + ... + Nx × Wx + θ * est transmis à la couche de sortie. D'autres incluent ** softmax ** et ** relu **.

• compile(...)

Lors de la compilation, des paramètres d'apprentissage détaillés sont définis. Définissez la fonction de perte que vous souhaitez minimiser lors de l'entraînement sur ** binary_crossentropy **, la fonction d'évaluation qui évalue les performances indépendamment de l'entraînement sur ** exactitude ** et la méthode d'optimisation sur ** sgd **.

• fit(...)

L'apprentissage est effectué ici. Spécifiez le modèle de test, le nombre d'époques et la taille du lot.

sample.ipynb

#Générer un constructeur de réseau neuronal
model = Sequential()

model.add(Dense(1, input_dim=2, activation='sigmoid')) # Dense(Nombre de neurones dans la couche,Nombre de dimensions d'entrée,Fonction d'activation)

#Paramètres d'apprentissage.compile(Fonction de perte,Méthode d'optimisation,Fonction d'évaluation)
model.compile(loss='binary_crossentropy',　optimizer='sgd', metrics=['accuracy'])

#Exécution de l'apprentissage
fg = model.fit(ip_train, class_train, epochs=1000, batch_size=1)
# Train on 4 samples
# Epoch 1/1000
# 4/4 [==============================] - 1s 137ms/sample - loss: 0.7022 - acc: 0.7500
# Epoch 2/1000
# 4/4 [==============================] - 0s 5ms/sample - loss: 0.7004 - acc: 0.7500
# Epoch 3/1000
# 4/4 [==============================] - 0s 5ms/sample - loss: 0.6987 - acc: 0.7500
#･ ･ ･
# Epoch 999/1000
# 4/4 [==============================] - 0s 4ms/sample - loss: 0.2649 - acc: 1.0000
# Epoch 1000/1000
# 4/4 [==============================] - 0s 3ms/sample - loss: 0.2647 - acc: 1.0000

Dessiner un graphique

Maintenant que la formation est terminée, j'aimerais utiliser prédire () pour prédire les limites et utiliser matplotlib pour afficher les résultats. Cette fois également, nous utiliserons des tranches pour extraire et afficher les données nécessaires. Il n'y a rien d'autre dans le code qui sera expliqué en détail, veuillez donc jeter un œil au code.

sample.ipynb

t1 = ip_train[ class_train==1 ] 
t0 = ip_train[ class_train==0 ]

#Un tableau de coordonnées x de points avec un signal enseignant de 1
t1_x = t1[:, 0] 
#Un tableau de coordonnées y de points avec un signal enseignant de 1
t1_y = t1[:, 1] 
t0_x = t0[:, 0]
t0_y = t0[:, 1]

# ','Lire GRIDFILE séparé par
g = np.loadtxt(GRIDFILE, delimiter=',')

#Prédire les limites à partir des résultats d'apprentissage
pred_g = model.predict(g)[:, 0]

#Un tableau de points avec une valeur prédite de 1
g1 = g[ pred_g >= 0.5 ]
#Un tableau de points avec une valeur prédite de 0
g0 = g[ pred_g < 0.5 ]

#Un tableau de coordonnées x de points avec une valeur prédite de 1
g1_x = g1[:, 0]
#Un tableau de coordonnées y de points avec une valeur prédite de 1
g1_y = g1[:, 1]

g0_x = g0[:, 0]
g0_y = g0[:, 1]

plt.scatter(t1_x, t1_y, marker='o', facecolor='black', s=100)
plt.scatter(t0_x, t0_y, marker='o', facecolor='white', edgecolor='black', s=100)
plt.scatter(g1_x, g1_y, marker='o', facecolor='black', s=20)
plt.scatter(g0_x, g0_y, marker='o', facecolor='white', edgecolor='black', s=20)
plt.show()

Quand je le lance, je ne vois pas les lignes, mais je pense que j'ai pu classer comme je m'y attendais. Le noir 〇 est la partie considérée comme le résultat de sortie 1 et le blanc 〇 est la partie considérée comme le résultat de sortie 0. C'est la fin, y compris la mise en œuvre.

finalement

J'ai parcouru à peu près l'implémentation du Perceptron simple le plus basique. Encore une fois, le but de cet article est ** d'avoir une idée approximative de l'apprentissage automatique et d'essayer d'implémenter un perceptron simple de base **, j'espère donc que cela vous donnera une chance de démarrer l'apprentissage automatique. Je vais. Au fur et à mesure que cela devient plus compliqué, il devient possible de distinguer ce qui est reflété dans l'image et d'identifier les données audio. Veuillez le vérifier et le mettre en œuvre. De plus, dans le Calendrier de l'Avent DMM WEBCAMP auquel je participe cette fois, des mentors seniors et des employés écrivent des articles plus étonnants. Si vous êtes intéressé, jetez un œil.

Page de référence

Lié à l'apprentissage automatique

Apprentissage automatique à partir de zéro (présentation de l'apprentissage automatique) [Différences entre l'apprentissage supervisé et l'apprentissage non supervisé - Technologie d'intelligence artificielle AI-](https://newtechnologylifestyle.net/%E6%95%99%E5%B8%AB%E3%81%82%E3%82% 8A% E5% AD% A6% E7% BF% 92% E3% 81% A8% E6% 95% 99% E5% B8% AB% E3% 81% AA% E3% 81% 97% E5% AD% A6% E7% BF% 92% E3% 81% AE% E9% 81% 95% E3% 81% 84% E3% 81% AB% E3% 81% A4% E3% 81% 84% E3% 81% A6 /) Deep Learning - Trois choses que vous devez savoir- [Analyse de cluster avec scikit-learn (méthode K-means) - Science des données avec Python](https://pythondatascience.plavox.info/scikit-learn/%E3%82%AF%E3%83%A9%E3%82] % B9% E3% 82% BF% E5% 88% 86% E6% 9E% 90-k-means)

Lié à Python

Comment installer Python (Windows)

En rapport avec Miniconda

Note d'utilisation de Miniconda - Note de lecture v1.5dev - Cabane préfabriquée Installer Miniconda sur Windows (2018) --Qiita [Pour les débutants] Créez un environnement virtuel avec Anaconda --Qiita Recommandation de Jupyter Lab --Qiita

Liés à Perse Proton

[À propos de la technologie d'intelligence artificielle Perceptron-AI la plus simple](https://newtechnologylifestyle.net/%E4%B8%80%E7%95%AA%E7%B0%A1%E5%8D%98%E3% 81% AA% E5% 8D% 98% E7% B4% 94% E3% 83% 91% E3% 83% BC% E3% 82% BB% E3% 83% 97% E3% 83% 88% E3% 83% AD% E3% 83% B3% E3% 81% AB% E3% 81% A4% E3% 81% 84% E3% 81% A6 /) Introduction au Deep Learning à partir de Keras / Tensorflow --Qiita Implémentation de Multi-layer Perceptron-Python et Machine Learning