Neuralt netværk drevet planetarium ved hjælp af Python, elektron og Keras: 8 trin

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:26

I denne instruktive vil jeg vise dig, hvordan jeg skrev en automatisk 3D planetariumgenerator ved hjælp af Python og Electron

Videoen ovenfor viser et af de tilfældige planetarier, som programmet genererede.

** Bemærk: Dette program er på ingen måde perfekt og nogle steder ikke særlig pytonisk. Den neurale netdiskriminator er kun ~ 89% præcis, så nogle ulige billeder vil komme ind på planetariet **

Specifikationer

Planetariet forespørger på en NASA API til rumrelaterede billeder og anvender et konvolutivt neuralt netværk til at afgøre, om billedet er egnet til behandling. Programmet bruger derefter OpenCV til at fjerne baggrunden fra billedet, og til sidst bliver billederne syet sammen til et stort ækvinkelformet billede. Dette billede gemmes derefter, og en Electron Node.js -applikation åbner billedet og bruger PhotoSphere.js -pakken til at se billedet i et 3D -format i planetariumstil.

Afhængigheder

Python:

• Keras
• Pude
• cv2
• Numpy
• Anmodninger
• urllib
• Tilfældig
• tid
• io

Elektron:

PhotoSphere

Trin 1: Opsætning af dit miljø

Installation af elektron og python

Sørg først for, at du har node.js og npm installeret (hvis ikke, kan du downloade her)

Dernæst skal du installere Electron. Åbn en kommandoprompt, og indtast følgende kommando:

npm installer elektron -g

Dernæst har du brug for python, som kan downloades her

Opsætning af et virtuelt miljø

Åbn en kommandoprompt, og indtast derefter følgende kommandoer for at konfigurere dit virtuelle miljø:

pip installere virtualenv

virtualenv plads

cd plads

scripts / aktivere

Installation af Python -afhængigheder

Kør disse kommandoer i kommandoprompten for at installere dine python -afhængigheder:

pip installer keras

pip installer pude

pip installer numpy

pip installationsanmodninger

pip installer opencv-pythonHvis du selv vil træne netværket, skal du sørge for at konfigurere GPU -acceleration til Keras

Trin 2: Forespørgsel efter NASA Search API

Oversigt

NASA har en masse virkelig nyttige API'er, som du kan bruge til dine projekter. Til dette projekt vil vi bruge søge-API'en, som giver os mulighed for at søge NASA's billeddatabase efter rumrelaterede billeder.

Koden

Først skal vi definere en python -funktion for at acceptere et argument, der vil fungere som søgeudtrykket:

def get_image_search (sætning):

passere

Dernæst konverterer vi søgeudtrykket til URL -format og bruger derefter forespørgselsbiblioteket til at forespørge API'en:

def get_image_search (sætning):

params = {"q": urllib.parse.quote (arg), "media_type": "image"} results = requests.get ("https://images-api.nasa.gov/search", params = params)

Endelig vil vi afkode den samling+JSON -streng, som API'en returnerede til os, og udtrække en liste med links til billeder relateret til søgeudtrykket:

def get_image_search (sætning):

params = {"q": urllib.parse.quote (arg), "media_type": "image"} results = requests.get ("https://images-api.nasa.gov/search", params = params) data = [resultat ['href'] for resultat i results.json () ["samling"] ["varer"]

Sådan der! Vi har nu et kodestykke, der kan forespørge NASAs billedsøgnings -API og returnere en liste med links til billeder, der er relateret til vores søgeudtryk.

Trin 3: Det konvolutionelle neurale netværk

Oversigt

Det neurale netværks opgave er at klassificere, om et billede er af noget i rummet, eller om det ikke er det. For at gøre dette vil vi bruge et konvolutionsnervalt netværk eller CNN til at udføre en række matrixoperationer på billedet og bestemme, hvor meget space-y det er. Jeg vil ikke forklare alt dette, for der er en masse teori bag det, men hvis du vil lære om neurale netværk, foreslår jeg "Machine Learning Mastery"

Koden

Først skal vi importere vores afhængigheder:

import os

#Fix for issue during train stepn oN GPU os.environ ['CUDA_VISIBLE_DEVICES'] = '' import tensorflow as tf if tf.test.gpu_device_name (): print ('GPU found') else: print ("Ingen GPU fundet") fra keras.preprocessing.image import ImageDataGenerator fra keras.preprocessing import image fra keras.models import Sequential fra keras.layers import Conv2D, MaxPooling2D fra keras.layers import Aktivering, Dropout, Flatten, Tæt fra keras import backend som K fra PIL import Image import numpy som np

Dernæst skal vi definere vores model:

img_width, img_height = 1000, 500

train_data_dir = 'v_data/train' validation_data_dir = 'v_data/test' nb_train_samples = 203 nb_validation_samples = 203 epochs = 10 batch_size = 8 if K.image_data_format () == 'channel_first': input_shape = (3, im_w = (img_width, img_height, 3) model = Sequential () model.add (Conv2D (32, (2, 2), input_shape = input_shape)) model.add (Activation ('relu')) model.add (MaxPooling2D (pool_size) = (2, 2))) model.add (Conv2D (32, (2, 2))) model.add (Activation ('relu')) model.add (MaxPooling2D (pool_size = (2, 2))) model.add (Conv2D (64, (2, 2))) model.add (Activation ('relu')) model.add (MaxPooling2D (pool_size = (2, 2))) model.add (Flatten ()) model. tilføj (Dense (64)) model.add (Activation ('relu')) model.add (Dropout (0.5)) model.add (Dense (1)) model.add (Activation ('sigmoid')) model.compile (loss = 'binary_crossentropy', optimizer = 'rmsprop', metrics = ['precision'])

Jeg har trænet modellen til dig, men hvis du gerne vil træne modellen selv, på dit eget datasæt, så har jeg vedhæftet træningskoden. Ellers kan du downloade den uddannede models HDF5 -fil. På grund af Instructables -filrestriktioner har jeg været nødt til at omdøbe det med en ".txt" -udvidelse. For at bruge den skal du omdøbe filen til en ".h5" -udvidelse og indlæse den med denne kode:

model.load_weights ("model_saved.h5")

For at bruge netværket til at forudsige, hvor mellemrum-y et billede er, vil vi definere denne funktion:

def forudsige (image_path):

img = image.load_img (image_path, target_size = (1000, 500)) img = np.expand_dims (img, axis = 0) result = model.predict_classes (img) return result [0] [0]

Trin 4: Behandling af billedet

Oversigt

Til billedbehandling bruger jeg OpenCV (cv2) biblioteket. Først vil vi sløre kanterne på billedet, og derefter fjerner vi baggrunden ved at oprette en maske og ændre alfa -værdierne for de mørkere farver

Koden

Dette er den del af funktionen, der slører kanterne:

def processImage (img):

RADIUS = 20 # Åbn et billede im = Image.open ("pilbuffer.png") # Indsæt billede på hvid baggrund diam = 2 * RADIUS back = Image.new ('RGB', (im.size [0] + diam, im.size [1] + diam), (0, 0, 0)) back.paste (im, (RADIUS, RADIUS)) # Opret sløring maske = Image.new ('L', (im.size [0] + diam, im.size [1] + diam), 255) blck = Image.new ('L', (im.size [0] - diam, im.size [1] - diam), 0) maske. indsæt (blck, (diam, diam)) # Slør billede og indsæt sløret kant i henhold til masksløring = tilbage.filter (ImageFilter. GaussianBlur (RADIUS / 2)) tilbage.paste (sløring, maske = maske) tilbage.save (" transition-p.webp

Dernæst sætter vi de mørkere farver til gennemsigtig og gemmer billedet midlertidigt:

#Opret maske og filter erstat sort med alfa

image = cv2.imread ("transition.png") hMin = 0 sMin = 0 vMin = 20 hMax = 180 sMax = 255 vMax = 255 lavere = np.array ([hMin, sMin, vMin]) øvre = np.array ([hMax, sMax, vMax]) hsv = cv2.cvtColor (billede, cv2. COLOR_BGR2HSV) mask = cv2.inRange (hsv, lavere, øvre) output = cv2.bitwise_and (billede, billede, maske = maske) *_, alpha = cv2.split (output) dst = cv2.merge ((output, alpha)) output = dst med åben ("buffer.png", "w+") som fil: pass cv2.imwrite ("buffer.png", output)

Trin 5: Sy billeder sammen til en lige -kantet projektion

Oversigt

Denne funktion tager flere billeder og sy dem i et format, der kan tolkes af PhotoSphere.js -pakken ved hjælp af PIL (pude) biblioteket

Koden

Først skal vi oprette et billede, der kan fungere som vært for de andre billeder:

ny = Image.new ("RGBA", (8000, 4000), farve = (0, 0, 0))

Dernæst skal vi iterere gennem arrayet af billeder (der alle er blevet ændret til 1000x500) og placere dem i billedet:

h = 0

w = 0 i = 0 for img i img_arr: new.paste (img, (w, h), img) w += 1000 hvis w == 8000: h += 500 w = 0 i += 1

Nu pakker vi bare dette ind i en funktion, der tager en række billeder som sit argument og returnerer det nye billede:

def stitch_beta (img_arr):

new = Image.new ("RGBA", (8000, 4000), color = (0, 0, 0)) h = 0 w = 0 i = 0 for img i img_arr: new.paste (img, (w, h), img) w += 1000 hvis w == 8000: h += 500 w = 0 i += 1 returnerer nyt

Trin 6: Det fulde Python -script

Dette er det fulde python neurale netværks script, som gemmes som net.py og importeres til hoved scriptet:

# import af biblioteker

import os #Fix for issue under train stepn oN GPU os.environ ['CUDA_VISIBLE_DEVICES'] = '' import tensorflow as tf if tf.test.gpu_device_name (): print ('GPU found') else: print ("Ingen GPU fundet ") fra keras.preprocessing.image import ImageDataGenerator fra keras.preprocessing import image fra keras.models import Sequential fra keras.layers import Conv2D, MaxPooling2D fra keras.layers import Aktivering, Dropout, Flatten, Tæt fra keras import backend som K fra PIL import Image import numpy as np img_width, img_height = 1000, 500 train_data_dir = 'v_data/train' validation_data_dir = 'v_data/test' nb_train_samples = 203 nb_validation_samples = 203 epochs = 10 batch_size = 8 if K.imat_data ': input_shape = (3, img_width, img_height) else: input_shape = (img_width, img_height, 3) model = Sequential () model.add (Conv2D (32, (2, 2), input_shape = input_shape)) model.add (Aktivering ('relu')) model.add (MaxPooling2D (pool_size = (2, 2))) model.add (Conv2D (32, (2, 2)))) model. tilføj (Activation ('relu')) model.add (MaxPooling2D (pool_size = (2, 2))) model.add (Conv2D (64, (2, 2))) model.add (Activation ('relu')) model.add (MaxPooling2D (pool_size = (2, 2))) model.add (Flatten ()) model.add (Dens (64)) model.add (Activation ('relu')) model.add (Dropout (0.5)) model.add (Dense (1)) model.add (Activation ('sigmoid')) model.compile (loss = 'binary_crossentropy', optimizer = 'rmsprop', metrics = ['precision']) model.load_weights ("model_saved.h5") def predict (image_path): img = image.load_img (image_path, target_size = (1000, 500)) img = np.expand_dims (img, axis = 0) result = model.predict_classes (img) return result [0] [0]

Dette er den vigtigste python -fil, api.py:

importanmodninger, sys, random, urllib.parse, cv2

fra PIL import Billede, ImageFilter fra io import BytesIO import numpy som np import net def get_image_search (num, sætning): count = 0 img_arr = for arg i sætning: print (arg) print (f "Aktuelt billedantal: {count } ") i = 0 params = {" q ": urllib.parse.quote (arg)," media_type ":" image "} results = requests.get (" https://images-api.nasa.gov/search ", params = params) data = [result ['href'] for resultat i results.json () [" collection "] [" items "] print (len (data)) if num> len (data): num = len (data) mens tælling = num: break print (f "\ n {count} images retreived") return img_arr def stitch_beta (img_arr): new = Image.new ("RGBA", (8000, 4000), color = (0, 0, 0)) h = 0 w = 0 i = 0 for img i img_arr: #pbar.set_description (f "Behandler billede {i +1}") new.paste (img, (w, h), img) w += 1000 if w == 8000: h += 500 w = 0 i += 1 returnerer ny def procesImage (img): RADIUS = 20 # Åbn et billede im = Image.open ("pilbuffer.png") # Indsæt billede på hvid baggrund diam = 2 * RADIUS tilbage = Image.new ('RGB', (im.size [0] + diam, im.size [1] + diam), (0, 0, 0)) back.paste (im, (RADIUS, RADIUS)) # Opret sløring maske = Image.new ('L', (im.size [0] + diam, im.size [1] + diam), 255) blck = Image.new ('L', (im.størrelse [0] - diam, im.size [1] - diam), 0) mask.paste (blck, (diam, diam)) # Slør billede og indsæt sløret kant i henhold til maske -sløring = bagfilter (ImageFilter. GaussianBlur (RADIUS / 2)) back.paste (blur, mask = mask) back.save ("transition.png") back.close () #Opret maske og filter erstat sort med alfa image = cv2.imread (" transit ion.png ") hMin = 0 sMin = 0 vMin = 20 hMax = 180 sMax = 255 vMax = 255 lavere = np.array ([hMin, sMin, vMin]) øvre = np.array ([hMax, sMax, vMax]) hsv = cv2.cvtColor (billede, cv2. COLOR_BGR2HSV) maske = cv2.inRange (hsv, nedre, øvre) output = cv2.bitwise_and (billede, billede, maske = maske) *_, alfa = cv2.split (output) dst = cv2.merge ((output, alpha)) output = dst med åben ("buffer.png", "w+") som fil: pass cv2.imwrite ("buffer.png", output) #Kantdetektering og sløring hvis _name_ == "_main_": search_terms = ["supernova", "planet", "galaxy", "milky way", "nebula", "stars"] #Søgeudtrykkene kan ændres til, hvad du vil, at planetariet skal inkludere img_arr = get_image_search (64, search_terms) print ("Billeder hentet og neuralt filtreret") img = stitch_beta (img_arr) print ("Images stitched") img.save ("stitched.png")

Trin 7: Elektron -appen

Oversigt

Vi opretter en simpel elektron -app, der bare placerer og indlæser PhotoSphere -elementet. Main.js- og package.json -filerne er direkte fra Electrons websted, og HTML -koden er en let ændret version af HTML -koden, der findes på PhotoSphere -webstedet. Jeg har inkluderet filerne, men omdøbt alle til.txt, da Instructables ikke tillader disse filtyper. Hvis du vil bruge filerne, skal du omdøbe dem med den relevante udvidelse.

Koden

main.js

const {app, BrowserWindow} = require ('elektron')

funktion createWindow () {const win = new BrowserWindow ({bredde: 800, højde: 600, webPreferences: {nodeIntegration: true}}) win.loadFile ('index.html')} app.whenReady (). derefter (createWindow) app.on ('window-all-closed', () => {if (process.platform! == 'darwin') {app.quit ()}}) app.on ('active', () => {if (BrowserWindow.getAllWindows (). length === 0) {createWindow ()}})

package.json

{

"name": "space", "version": "0.1.0", "main": "main.js", "scripts": {"start": "electron." }}

index.html

Trin 8: Udførelse

Oprettelse af det firkantede billede

For at oprette billedet skal du køre api.py -scriptet i kommandoprompten, med dets virtuelle miljø aktiveret:

api.py

Når scripts er færdige med at køre, skal du køre elektronappen ved hjælp af:

npm startVoila! Dit planetarium er aktivt! Tak fordi du læste:)