Oversikt

Denne omfattende veiledningen hjelper deg med å forberede deg til EdgeAI-kurset, som fokuserer på å bygge praktiske AI-løsninger som kjører effektivt på edge-enheter. Kurset legger vekt på praktisk utvikling ved bruk av moderne rammeverk og toppmoderne modeller optimalisert for edge-distribusjon.

1. Oppsett av utviklingsmiljø

Programmeringsspråk og rammeverk

Python-miljø

• Versjon: Python 3.10 eller nyere (anbefalt: Python 3.11)
• Pakkehåndtering: pip eller conda
• Virtuelt miljø: Bruk venv eller conda-miljøer for isolasjon
• Nøkkelbiblioteker: Vi installerer spesifikke EdgeAI-biblioteker under kurset

Microsoft .NET-miljø

• Versjon: .NET 8 eller nyere
• IDE: Visual Studio 2022, Visual Studio Code eller JetBrains Rider
• SDK: Sørg for at .NET SDK er installert for plattformuavhengig utvikling

Utviklingsverktøy

Kodeeditorer og IDE-er

• Visual Studio Code (anbefalt for plattformuavhengig utvikling)
• PyCharm eller Visual Studio (for språkspesifikk utvikling)
• Jupyter Notebooks for interaktiv utvikling og prototyping

Versjonskontroll

• Git (siste versjon)
• GitHub-konto for tilgang til repositorier og samarbeid

2. Maskinvarekrav og anbefalinger

Minimum systemkrav

• CPU: Flerkjernet prosessor (Intel i5/AMD Ryzen 5 eller tilsvarende)
• RAM: Minimum 8GB, anbefalt 16GB
• Lagring: 50GB ledig plass for modeller og utviklingsverktøy
• OS: Windows 10/11, macOS 10.15+ eller Linux (Ubuntu 20.04+)

Strategi for beregningsressurser

Kurset er designet for å være tilgjengelig på ulike maskinvarekonfigurasjoner:

Lokal utvikling (fokus på CPU/NPU)

• Primær utvikling vil bruke CPU og NPU-akselerasjon
• Egnet for de fleste moderne bærbare og stasjonære datamaskiner
• Fokus på effektivitet og praktiske distribusjonsscenarier

Skybaserte GPU-ressurser (valgfritt)

• Azure Machine Learning: For intensiv trening og eksperimentering
• Google Colab: Gratis nivå tilgjengelig for utdanningsformål
• Kaggle Notebooks: Alternativ skybasert plattform

Betraktninger for edge-enheter

• Forståelse av ARM-baserte prosessorer
• Kunnskap om begrensninger for mobile og IoT-enheter
• Kjennskap til optimalisering av strømforbruk

3. Kjernefamilier av modeller og ressurser

Primære modelfamilier

Microsoft Phi-4-familien

• Beskrivelse: Kompakte, effektive modeller designet for edge-distribusjon
• Styrker: Utmerket ytelse i forhold til størrelse, optimalisert for resonnement
• Ressurs: Phi-4 Collection på Hugging Face
• Bruksområder: Kodegenerering, matematisk resonnement, generell samtale

Qwen-3-familien

• Beskrivelse: Alibabas nyeste generasjon av flerspråklige modeller
• Styrker: Sterke flerspråklige evner, effektiv arkitektur
• Ressurs: Qwen-3 Collection på Hugging Face
• Bruksområder: Flerspråklige applikasjoner, tverrkulturelle AI-løsninger

Google Gemma-3n-familien

• Beskrivelse: Googles lette modeller optimalisert for edge-distribusjon
• Styrker: Rask inferens, mobilvennlig arkitektur
• Ressurs: Gemma-3n Collection på Hugging Face
• Bruksområder: Mobilapplikasjoner, sanntidsbehandling

Kriterier for modellvalg

• Ytelse vs. størrelse: Forstå når man skal velge mindre vs. større modeller
• Oppgavespesifikk optimalisering: Matche modeller til spesifikke bruksområder
• Distribusjonsbegrensninger: Minne, latens og strømforbruk

4. Kvantisering og optimaliseringsverktøy

Llama.cpp-rammeverk

• Repository: Llama.cpp på GitHub
• Formål: Høyytelses inferensmotor for LLM-er
• Nøkkelfunksjoner:
  • CPU-optimalisert inferens
  • Flere kvantiseringsformater (Q4, Q5, Q8)
  • Plattformuavhengig kompatibilitet
  • Minneeffektiv kjøring
• Installasjon og grunnleggende bruk:

  # Clone the repository
  git clone https://github.com/ggml-org/llama.cpp.git
  cd llama.cpp
  
  # Build the project with optimizations
  mkdir build && cd build
  cmake .. -DCMAKE_BUILD_TYPE=Release
  cmake --build . --config Release
  
  # Quantize a model (from GGUF format to 4-bit quantization)
  ./quantize ../models/original-model.gguf ../models/quantized-model-q4_0.gguf q4_0
  
  # Run inference with the quantized model
  ./main -m ../models/quantized-model-q4_0.gguf -n 512 -p "Write a function to calculate fibonacci numbers in Python:"
  

Microsoft Olive

• Repository: Microsoft Olive på GitHub

• Formål: Verktøysett for modelloptimalisering for edge-distribusjon

• Nøkkelfunksjoner:

  • Automatiserte arbeidsflyter for modelloptimalisering
  • Maskinvarebevisst optimalisering
  • Integrasjon med ONNX Runtime
  • Verktøy for ytelsesbenchmarking

• Installasjon og grunnleggende bruk:

  # Install Olive
  pip install olive-ai
  

  Eksempel på Python-skript for modelloptimalisering

  from olive.model import ONNXModel
  from olive.workflows import run_workflow
  
  # Define model and optimization config
  model = ONNXModel("original_model.onnx")
  config = {
      "input_model": model,
      "systems": {
          "local_system": {
              "type": "LocalSystem"
          }
      },
      "engine": {
          "log_severity_level": 0,
          "cache_dir": "cache"
      },
      "passes": {
          "quantization": {
              "type": "OrtQuantization",
              "config": {
                  "quant_mode": "static",
                  "activation_type": "int8",
                  "weight_type": "int8"
              }
          }
      }
  }
  
  # Run optimization workflow
  result = run_workflow(config)
  optimized_model = result.optimized_model
  
  # Save optimized model
  optimized_model.save("optimized_model.onnx")
  

Apple MLX (macOS-brukere)

• Repository: Apple MLX på GitHub

• Formål: Maskinlæringsrammeverk for Apple Silicon

• Nøkkelfunksjoner:

  • Naturlig optimalisering for Apple Silicon
  • Minneeffektive operasjoner
  • PyTorch-lignende API
  • Støtte for enhetlig minnearkitektur

• Installasjon og grunnleggende bruk:

  # Install MLX
  pip install mlx
  

  # Example Python script for loading and optimizing a model
  import mlx.core as mx
  import mlx.nn as nn
  from mlx.utils import tree_flatten
  
  # Load pre-trained weights (example with a simple MLP)
  class MLP(nn.Module):
      def __init__(self, dim=768, hidden_dim=3072):
          super().__init__()
          self.fc1 = nn.Linear(dim, hidden_dim)
          self.fc2 = nn.Linear(hidden_dim, dim)
          
      def __call__(self, x):
          return self.fc2(mx.maximum(0, self.fc1(x)))
  
  # Create model and load weights
  model = MLP()
  weights = mx.load("original_weights.npz")
  model.update(weights)
  
  # Quantize the model weights to FP16
  def quantize_weights(model):
      params = {}
      for k, v in tree_flatten(model.parameters()):
          params[k] = v.astype(mx.float16)
      model.update(params)
      return model
  
  quantized_model = quantize_weights(model)
  
  # Save quantized model
  mx.save("quantized_model.npz", quantized_model.parameters())
  
  # Run inference
  input_data = mx.random.normal((1, 768))
  output = quantized_model(input_data)
  

ONNX Runtime

• Repository: ONNX Runtime på GitHub

• Formål: Plattformuavhengig akselerasjon for ONNX-modeller

• Nøkkelfunksjoner:

  • Maskinvarespesifikke optimaliseringer (CPU, GPU, NPU)
  • Grafoptimaliseringer for inferens
  • Støtte for kvantisering
  • Støtte for flere språk (Python, C++, C#, JavaScript)

• Installasjon og grunnleggende bruk:

  # Install ONNX Runtime
  pip install onnxruntime
  
  # For GPU support
  pip install onnxruntime-gpu
  

  import onnxruntime as ort
  import numpy as np
  
  # Create inference session with optimizations
  sess_options = ort.SessionOptions()
  sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
  sess_options.enable_profiling = True  # Enable performance profiling
  
  # Create session with provider selection for hardware acceleration
  providers = ['CUDAExecutionProvider', 'CPUExecutionProvider']  # Use GPU if available
  session = ort.InferenceSession("model.onnx", sess_options, providers=providers)
  
  # Prepare input data
  input_name = session.get_inputs()[0].name
  input_shape = session.get_inputs()[0].shape
  input_data = np.random.rand(*input_shape).astype(np.float32)
  
  # Run inference
  outputs = session.run(None, {input_name: input_data})
  
  # Get profiling data
  prof_file = session.end_profiling()
  print(f"Profiling data saved to: {prof_file}")
  

5. Anbefalt lesing og ressurser

Viktig dokumentasjon

• ONNX Runtime-dokumentasjon: Forstå plattformuavhengig inferens
• Hugging Face Transformers Guide: Modellinnlasting og inferens
• Edge AI Design Patterns: Beste praksis for edge-distribusjon

Teknisk litteratur

• "Efficient Edge AI: A Survey of Quantization Techniques"
• "Model Compression for Mobile and Edge Devices"
• "Optimizing Transformer Models for Edge Computing"

Fellesskapsressurser

• EdgeAI Slack/Discord-fellesskap: Støtte og diskusjon med jevnaldrende
• GitHub-repositorier: Eksempelimplementeringer og veiledninger
• YouTube-kanaler: Teknisk fordypning og opplæringsvideoer

6. Vurdering og verifisering

Sjekkliste før kursstart

• Python 3.10+ installert og verifisert
• .NET 8+ installert og verifisert
• Utviklingsmiljø konfigurert
• Hugging Face-konto opprettet
• Grunnleggende kjennskap til målmodeller
• Kvantiseringsverktøy installert og testet
• Maskinvarekrav oppfylt
• Skykontoer opprettet (hvis nødvendig)

Viktige læringsmål

Ved slutten av denne veiledningen vil du kunne:

1. Sette opp et komplett utviklingsmiljø for EdgeAI-applikasjonsutvikling
2. Installere og konfigurere nødvendige verktøy og rammeverk for modelloptimalisering
3. Velge passende maskinvare- og programvarekonfigurasjoner for EdgeAI-prosjektene dine
4. Forstå nøkkelbetraktninger for distribusjon av AI-modeller på edge-enheter
5. Forberede systemet ditt for de praktiske øvelsene i kurset

Tilleggsressurser

Offisiell dokumentasjon

• Python-dokumentasjon: Offisiell dokumentasjon for Python-språket
• Microsoft .NET-dokumentasjon: Offisielle ressurser for .NET-utvikling
• ONNX Runtime-dokumentasjon: Omfattende guide til ONNX Runtime
• TensorFlow Lite-dokumentasjon: Offisiell dokumentasjon for TensorFlow Lite

Utviklingsverktøy

• Visual Studio Code: Lettvekts kodeeditor med AI-utviklingsutvidelser
• Jupyter Notebooks: Interaktivt miljø for ML-eksperimentering
• Docker: Plattform for containerisering for konsistente utviklingsmiljøer
• Git: Versjonskontrollsystem for kodehåndtering

Læringsressurser

• EdgeAI-forskningsartikler: Nyeste akademiske forskning på effektive modeller
• Nettkurs: Supplerende læringsmateriale om AI-optimalisering
• Fellesskapsfora: Spørsmål og svar-plattformer for EdgeAI-utviklingsutfordringer
• Benchmark-datasett: Standard datasett for evaluering av modellytelse

Læringsutbytte

Etter å ha fullført denne forberedelsesveiledningen vil du:

1. Ha et fullt konfigurert utviklingsmiljø klart for EdgeAI-utvikling
2. Forstå maskinvare- og programvarekrav for ulike distribusjonsscenarier
3. Være kjent med nøkkelrammeverk og verktøy som brukes gjennom kurset
4. Kunne velge passende modeller basert på enhetsbegrensninger og krav
5. Ha grunnleggende kunnskap om optimaliseringsteknikker for edge-distribusjon

➡️ Hva er neste steg

• 04: EdgeAI-maskinvare og distribusjon

---

Ansvarsfraskrivelse:
Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten Co-op Translator. Selv om vi tilstreber nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.