[PYTHON] [kotlin] Créez une application de reconnaissance d'images en temps réel sur Android
Que faire cette fois
Créez une application qui reconnaît l'image (image) capturée par la caméra sur Android en temps réel. Exécutez le modèle entraîné sur Android à l'aide de PyTorch Mobile.
Ce ↓
L'exemple d'application que j'ai créé est répertorié en bas, veuillez donc y jeter un œil si vous le souhaitez.
Dépendances
Tout d'abord, ajoutez des dépendances (à partir de février 2020) appareil photo x et pytorch mobile
build.gradle
def camerax_version = '1.0.0-alpha06'
implementation "androidx.camera:camera-core:${camerax_version}"
implementation "androidx.camera:camera-camera2:${camerax_version}"
implementation 'org.pytorch:pytorch_android:1.4.0'
implementation 'org.pytorch:pytorch_android_torchvision:1.4.0'
Ajoutez ce qui suit à la fin du ** android {} ** supérieur
build.gradle
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
Implémentation de la caméra X
Après avoir ajouté la dépendance, nous allons implémenter la fonction pour prendre une photo en utilisant ** Camera X **, une bibliothèque qui facilite la manipulation de la caméra sur Android.
Ci-dessous, nous allons mettre en œuvre le [Tutoriel] officiel de Camera X (https://codelabs.developers.google.com/codelabs/camerax-getting-started/#0). Les détails sont mentionnés dans d'autres articles, alors omettez-les et codez simplement.
Manifeste
Octroi de permission
<uses-permission android:name="android.permission.CAMERA" />
Disposition
Disposer un bouton pour démarrer la caméra et une vue de texture pour l'affichage de l'aperçu
activity_main.xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<TextureView
android:id="@+id/view_finder"
android:layout_width="0dp"
android:layout_height="0dp"
android:layout_marginBottom="16dp"
app:layout_constraintBottom_toTopOf="@+id/activateCameraBtn"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
<androidx.constraintlayout.widget.ConstraintLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:alpha="0.7"
android:animateLayoutChanges="true"
android:background="@android:color/white"
app:layout_constraintEnd_toEndOf="@+id/view_finder"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="@+id/view_finder">
<TextView
android:id="@+id/inferredCategoryText"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_marginStart="8dp"
android:layout_marginTop="16dp"
android:layout_marginEnd="8dp"
android:text="Résultat d'inférence"
android:textSize="18sp"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
<TextView
android:id="@+id/inferredScoreText"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginStart="24dp"
android:layout_marginTop="16dp"
android:text="But"
android:textSize="18sp"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toBottomOf="@+id/inferredCategoryText" />
</androidx.constraintlayout.widget.ConstraintLayout>
<Button
android:id="@+id/activateCameraBtn"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginBottom="16dp"
android:text="Activation de la caméra"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>
use case Camera X propose trois cas d'utilisation: ** aperçu, capture d'image et analyse d'image **. Cette fois, nous utiliserons l'aperçu et l'analyse d'image. La correspondance avec le cas d'utilisation facilite le tri du code. À propos, les combinaisons possibles sont les suivantes. (De document officiel)
Cas d'utilisation de l'aperçu implémenté
Nous implémenterons jusqu'à l'aperçu du cas d'utilisation de Camera X. Presque le même contenu que Tutorial.
MainActivity.kt
private const val REQUEST_CODE_PERMISSIONS = 10
private val REQUIRED_PERMISSIONS = arrayOf(Manifest.permission.CAMERA)
class MainActivity : AppCompatActivity(), LifecycleOwner {
private val executor = Executors.newSingleThreadExecutor()
private lateinit var viewFinder: TextureView
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
viewFinder = findViewById(R.id.view_finder)
//Activation de la caméra
activateCameraBtn.setOnClickListener {
if (allPermissionsGranted()) {
viewFinder.post { startCamera() }
} else {
ActivityCompat.requestPermissions(
this, REQUIRED_PERMISSIONS, REQUEST_CODE_PERMISSIONS
)
}
}
viewFinder.addOnLayoutChangeListener { _, _, _, _, _, _, _, _, _ ->
updateTransform()
}
}
private fun startCamera() {
//Implémentation de l'aperçu useCase
val previewConfig = PreviewConfig.Builder().apply {
setTargetResolution(Size(viewFinder.width, viewFinder.height))
}.build()
val preview = Preview(previewConfig)
preview.setOnPreviewOutputUpdateListener {
val parent = viewFinder.parent as ViewGroup
parent.removeView(viewFinder)
parent.addView(viewFinder, 0)
viewFinder.surfaceTexture = it.surfaceTexture
updateTransform()
}
/**Nous implémenterons l'analyse d'image useCase ici plus tard.**/
CameraX.bindToLifecycle(this, preview)
}
private fun updateTransform() {
val matrix = Matrix()
val centerX = viewFinder.width / 2f
val centerY = viewFinder.height / 2f
val rotationDegrees = when (viewFinder.display.rotation) {
Surface.ROTATION_0 -> 0
Surface.ROTATION_90 -> 90
Surface.ROTATION_180 -> 180
Surface.ROTATION_270 -> 270
else -> return
}
matrix.postRotate(-rotationDegrees.toFloat(), centerX, centerY)
//Reflété dans textureView
viewFinder.setTransform(matrix)
}
override fun onRequestPermissionsResult(
requestCode: Int, permissions: Array<String>, grantResults: IntArray
) {
if (requestCode == REQUEST_CODE_PERMISSIONS) {
if (allPermissionsGranted()) {
viewFinder.post { startCamera() }
} else {
Toast.makeText(
this,
"Permissions not granted by the user.",
Toast.LENGTH_SHORT
).show()
finish()
}
}
}
private fun allPermissionsGranted() = REQUIRED_PERMISSIONS.all {
ContextCompat.checkSelfPermission(
baseContext, it
) == PackageManager.PERMISSION_GRANTED
}
}
Préparation du modèle et classe de classification
Cette fois, j'utiliserai le resnet18 formé.
- Si vous avez un environnement pytorch python, exécutez le code suivant avec python, si vous ne l'avez pas, github Téléchargez resnet.pt depuis.
import torch
import torchvision
model = torchvision.models.resnet18(pretrained=True)
model.eval()
example = torch.rand(1, 3, 224, 224)
traced_script_module = torch.jit.trace(model, example)
traced_script_module.save("resnet.pt")
S'il peut être exécuté avec succès, un fichier appelé resnet.pt sera généré dans la même hiérarchie. La reconnaissance d'image sera effectuée à l'aide de ce resnet18 formé.
Placez le modèle téléchargé dans le ** dossier d'actifs ** d'Android Studio. (Comme il n'existe pas par défaut, vous pouvez le créer en faisant un clic droit sur le dossier res-> Nouveau-> Dossier-> Dossier Asset)
Écrivez la classe ImageNet dans un fichier pour la convertir en nom de classe après avoir déduit. Créez un nouveau ** ImageNetClasses.kt ** et écrivez-y 1000 classes d'ImageNet. C'est trop long, alors copiez-le depuis github.
ImageNetClasses.kt
class ImageNetClasses {
var IMAGENET_CLASSES = arrayOf(
"tench, Tinca tinca",
"goldfish, Carassius auratus",
//Abréviation(Veuillez copier depuis github)
"ear, spike, capitulum",
"toilet tissue, toilet paper, bathroom tissue"
)
}
Créer un cas d'utilisation d'analyse d'image
Ensuite, nous implémenterons l'analyse d'image pour le cas d'utilisation de Camera X. Créez un nouveau fichier appelé ImageAnalyze.kt et effectuez un traitement de reconnaissance d'image.
Dans le flux, chargez le modèle et utilisez le cas d'utilisation de l'analyse d'image pour convertir l'image d'aperçu en tenseur afin qu'elle puisse être utilisée avec pytorch mobile, puis transmettez le modèle chargé à partir du dossier d'actifs plus tôt pour obtenir le résultat.
Après cela, j'ai écrit une interface et un écouteur personnalisé pour refléter le résultat de l'inférence dans la vue. (Je ne sais pas comment écrire correctement ici, alors faites-moi savoir s'il existe une façon intelligente de l'écrire.)
ImageAnalyze.kt
class ImageAnalyze(context: Context) : ImageAnalysis.Analyzer {
private lateinit var listener: OnAnalyzeListener //Écouteur personnalisé pour la mise à jour de la vue
private var lastAnalyzedTimestamp = 0L
//Chargement d'un modèle de modèle de réseau
private val resnet = Module.load(getAssetFilePath(context, "resnet.pt"))
interface OnAnalyzeListener {
fun getAnalyzeResult(inferredCategory: String, score: Float)
}
override fun analyze(image: ImageProxy, rotationDegrees: Int) {
val currentTimestamp = System.currentTimeMillis()
if (currentTimestamp - lastAnalyzedTimestamp >= 0.5) { // 0.Infer toutes les 5 secondes
lastAnalyzedTimestamp = currentTimestamp
//Convertir en tenseur(Lorsque j'ai vérifié le format d'image, YUV_420_Il s'appelait 888)
val inputTensor = TensorImageUtils.imageYUV420CenterCropToFloat32Tensor(
image.image,
rotationDegrees,
224,
224,
TensorImageUtils.TORCHVISION_NORM_MEAN_RGB,
TensorImageUtils.TORCHVISION_NORM_STD_RGB
)
//Inférer avec un modèle entraîné
val outputTensor = resnet.forward(IValue.from(inputTensor)).toTensor()
val scores = outputTensor.dataAsFloatArray
var maxScore = 0F
var maxScoreIdx = 0
for (i in scores.indices) { //Obtenez l'index avec le score le plus élevé
if (scores[i] > maxScore) {
maxScore = scores[i]
maxScoreIdx = i
}
}
//Obtenir le nom de la catégorie à partir du score
val inferredCategory = ImageNetClasses().IMAGENET_CLASSES[maxScoreIdx]
listener.getAnalyzeResult(inferredCategory, maxScore) //Mettre à jour la vue
}
}
////Fonction pour obtenir le chemin du fichier d'actif
private fun getAssetFilePath(context: Context, assetName: String): String {
val file = File(context.filesDir, assetName)
if (file.exists() && file.length() > 0) {
return file.absolutePath
}
context.assets.open(assetName).use { inputStream ->
FileOutputStream(file).use { outputStream ->
val buffer = ByteArray(4 * 1024)
var read: Int
while (inputStream.read(buffer).also { read = it } != -1) {
outputStream.write(buffer, 0, read)
}
outputStream.flush()
}
return file.absolutePath
}
}
fun setOnAnalyzeListener(listener: OnAnalyzeListener){
this.listener = listener
}
}
J'étais confus par le type d'image inconnu appelé ImageProxy, mais lorsque j'ai vérifié le format, j'ai pensé que je devais le convertir en bitmap avec YUV_420_888, mais pytorch mobile a une méthode pour convertir de YUV_420 en tenseur, et cela peut être facilement déduit simplement en le jetant. C'était.
En passant, si vous regardez le code, vous avez peut-être pensé qu'il était en temps réel, mais il est par incréments de 0,5 seconde.
Incorporer le cas d'utilisation de l'analyse d'image
Introduction de la classe ImageAnalyze créée précédemment dans Camera X en tant que cas d'utilisation, et enfin implémentation de l'interface de la classe ImageAnalyze dans MainActivity à l'aide d'un objet anonyme, et complétée afin que la vue puisse être mise à jour.
Ajoutez le code suivant à la fin de onCreate. (En haut, j'ai commenté "/ ** Je vais implémenter l'analyse d'image useCase ici ** /" plus tard)
MainActivity.kt
//Mise en œuvre de l'analyse d'image useCase
val analyzerConfig = ImageAnalysisConfig.Builder().apply {
setImageReaderMode(
ImageAnalysis.ImageReaderMode.ACQUIRE_LATEST_IMAGE
)
}.build()
//exemple
val imageAnalyzer = ImageAnalyze(applicationContext)
//Afficher les résultats de l'inférence
imageAnalyzer.setOnAnalyzeListener(object : ImageAnalyze.OnAnalyzeListener {
override fun getAnalyzeResult(inferredCategory: String, score: Float) {
//Changer la vue à partir d'un autre que le thread principal
viewFinder.post {
inferredCategoryText.text = "Résultat d'inférence: $inferredCategory"
inferredScoreText.text = "But: $score"
}
}
})
val analyzerUseCase = ImageAnalysis(analyzerConfig).apply {
setAnalyzer(executor, imageAnalyzer)
}
//useCase est un aperçu et une analyse d'image
CameraX.bindToLifecycle(this, preview, analyzerUseCase) //Ajout d'une analyse d'image au cas d'utilisation
Achevée! !! Ceux qui l'ont mis en œuvre avec succès jusqu'à présent devraient avoir terminé la demande au début. Veuillez jouer avec.
fin
Ce code est répertorié dans github, veuillez donc vous y référer le cas échéant.
Camera X Vraiment pratique! Vous pouvez facilement effectuer une analyse d'image en combinaison avec pytroch mobile. Il ne peut pas être aidé que le traitement le rend un peu plus lourd. Si vous pouvez préparer un modèle, vous pouvez facilement créer diverses applications de reconnaissance d'image à l'aide d'un appareil photo. Après tout, je me demande s'il est rapide de créer une application utilisant ce modèle comme l'apprentissage par transfert.
Je souhaite créer et publier une application d'apprentissage automatique ... ~~ Nous prévoyons de créer un exemple d'application dans un proche avenir. (En cours de révision) ~~
J'ai créé un exemple d'application
Je l'ai ajouté parce qu'il a réussi l'examen. J'ai essayé d'incorporer le contenu écrit dans cet article dans l'application. Il est publié sur le Play Store.
Si vous souhaitez en faire l'expérience rapidement ou si vous souhaitez le télécharger, nous vous serions reconnaissants de bien vouloir le télécharger.
Analyseur d'objets
Play Store: Object Analyzer
Prise en charge de l'anglais et du japonais
Pour être honnête, il y a une grande différence entre ce qui peut être jugé et ce qui ne peut pas être jugé ...
Recommended Posts