如何在iOS应用中运行含TensorFlow模块的Python脚本？求教程文档

Hey there! I’ve worked through this exact problem before, so let me break down two solid approaches to get your TensorFlow-powered Python script up and running on iOS—one built for top-tier performance (great for production), and another that lets you run your original Python code directly (perfect for quick prototypes).

Approach 1: Convert Your Python Script to a TensorFlow Lite Model (Recommended for Production) #

This is the official, performance-optimized way to run TensorFlow on iOS. It strips out unnecessary parts of the full TensorFlow library and gives you a lightweight, fast model. Here’s how to do it:

• Step 1: Export your TensorFlow model as a SavedModel
  First, in your Python environment, save your trained model or inference graph as a SavedModel folder. If your script uses a pre-trained model, you can skip training and just export the inference graph:

  # Example: Save a trained Keras model
  import tensorflow as tf
  
  # Assume you have a trained model object (e.g., from model.fit())
  model = tf.keras.models.load_model("trained_model.h5")
  model.save("my_tf_saved_model")  # Creates a folder with SavedModel files
  

• Step 2: Convert SavedModel to TensorFlow Lite format
  Use TensorFlow’s Lite Converter to turn the SavedModel into a .tflite file. Add support for select TensorFlow ops if your script uses custom operations that aren’t in the default TFLite built-ins:

  converter = tf.lite.TFLiteConverter.from_saved_model("my_tf_saved_model")
  # Uncomment below if you need custom TF ops
  # converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS, tf.lite.OpsSet.SELECT_TF_OPS]
  tflite_model = converter.convert()
  
  # Save the converted model
  with open("my_model.tflite", "wb") as f:
      f.write(tflite_model)
  

• Step 3: Integrate TensorFlow Lite into your iOS app

  1. Add the TensorFlow Lite Swift pod to your Podfile:

     pod 'TensorFlowLiteSwift'
     

     Then run pod install in your terminal to install the dependency.
  2. Drag the my_model.tflite file into your Xcode project, making sure to check "Copy items if needed" so it’s included in your app bundle.
  3. Write Swift code to load the model and run inference. Here’s a basic example:

     import TensorFlowLiteSwift
     
     func runModelWithInput(_ inputData: Data) -> Data? {
         guard let modelPath = Bundle.main.path(forResource: "my_model", ofType: "tflite") else {
             print("Model file not found in bundle")
             return nil
         }
     
         do {
             let interpreter = try Interpreter(modelPath: modelPath)
             try interpreter.allocateTensors()
     
             // Copy input data to the model's input tensor
             try interpreter.copy(inputData, toInputAt: 0)
     
             // Run inference
             try interpreter.invoke()
     
             // Retrieve output data
             let outputTensor = try interpreter.output(at: 0)
             return outputTensor.data
         } catch {
             print("Error running model: \(error.localizedDescription)")
             return nil
         }
     }
     

  4. Bonus: If your Python script includes pre/post-processing logic (like resizing images or normalizing data), rewrite that logic in Swift for best performance. You can also use the TensorFlow Lite Support library to simplify data handling.

Approach 2: Embed a Python Environment in iOS (For Prototyping) #

If you want to run your original Python script without rewriting it, you can embed a Python runtime in your app. Note that this is slower than TensorFlow Lite and better suited for quick testing, not production.

Option A: Use PythonKit with a Custom Compiled Python #

1. Compile a Python static library for iOS: You’ll need to build a version of Python that works on iOS (since official Python doesn’t support iOS out of the box). Tools like pyenv or cctools-port can help with this.
2. Add TensorFlow Lite Runtime: Instead of the full TensorFlow library, use the lightweight tflite-runtime Python package (compile it for your iOS Python build or find a pre-built version).
3. Integrate PythonKit: Add the PythonKit pod to your project, then load and run your script:

   import PythonKit
   
   func runPythonScript() {
       // Set the path to your Python scripts folder
       guard let scriptsPath = Bundle.main.path(forResource: "scripts", ofType: nil) else {
           print("Scripts folder not found")
           return
       }
   
       let sys = Python.import("sys")
       sys.path.append(scriptsPath)
   
       // Import your script and run its inference function
       let myTensorFlowScript = Python.import("my_script")
       let result = myTensorFlowScript.run_inference(yourInputData)
   
       // Convert the Python result to a native iOS type (e.g., Data, Array)
       let nativeResult = convertPythonResultToNative(result)
   }
   

Option B: Use Pyodide (WebAssembly) #

Run your Python script in a WKWebView using Pyodide (a WebAssembly port of Python):

1. Download the Pyodide files (e.g., pyodide.js, pyodide.asm.js) and add them to your Xcode project.
2. Create an HTML file that loads Pyodide, imports tflite-runtime, and runs your script.
3. Load the HTML file in a WKWebView and communicate between the web view and your iOS app using JavaScript bridges.

Key Notes to Avoid Headaches #

• Always prefer TensorFlow Lite for production: It’s optimized for iOS’s memory and performance constraints, and Apple’s App Store guidelines favor lightweight, efficient apps.
• Avoid full TensorFlow in iOS Python environments: The full TensorFlow library is too large for iOS, and there’s no official wheel package. Stick to tflite-runtime instead.
• Sandbox permissions: If your script needs to read/write files, make sure your iOS app has the necessary permissions (e.g., "Files and Folders" access) and that you’re working within the app’s sandbox directory.

内容的提问来源于stack exchange，提问作者J.Chiueh