import CoreImage import Foundation import Testing @testable import FaceMaker @Suite("FaceMaker") struct FaceMakerTests { /// Repo ./models, where the ONNX weights are staged (same convention as /// FaceReplace's tests). static var modelsDirectory: URL { URL(fileURLWithPath: #filePath) .deletingLastPathComponent() // FaceMakerTests .deletingLastPathComponent() // Tests .deletingLastPathComponent() // repo root .appendingPathComponent("models") } /// End-to-end nearest-neighbour inversion, fully offline: generate a face, /// then drop it back in — Vision must find the face, ArcFace must embed it, /// and the search must return a 512-d latent. Skips if models aren't staged. @Test("Drop-to-vector finds a nearest latent") func inversion() async throws { let directory = Self.modelsDirectory let fm = FileManager.default guard fm.fileExists(atPath: directory.appendingPathComponent("w600k_r50.onnx").path), fm.fileExists(atPath: directory.appendingPathComponent( "mobilestylegan_ffhq_v2-synth.onnx").path) else { return } // models not staged — nothing to verify let model = try #require(LocalFaceModel.find("local/mobilestylegan-ffhq")) // A query well outside the small bank's seeds (1...target), so the // nearest match is loose and refinement has room to improve it. let png = try await FaceLocalEngine.shared.png( model: model, directory: directory, latent: FaceLocalEngine.gaussianLatent(seed: 987_654_321)) let image = try #require(CIImage(data: png)) let query = try #require( await FaceInversion.shared.embedDropped(image, directory: directory)) let seed = try await FaceInversion.shared.nearest( to: query, model: model, directory: directory, target: 8, progress: { _, _ in }) #expect(seed.count == 512) // Refinement should move the latent no further from — and in practice // much closer to — the (in-distribution) target identity. let seedSim = try #require( try await FaceInversion.shared.similarity( of: seed, to: query, model: model, directory: directory)) let refined = try await FaceInversion.shared.refine( query: query, start: seed, model: model, directory: directory, iterations: 5, lambda: 4, progress: { _, _, _, _ in }) let refinedSim = try #require( try await FaceInversion.shared.similarity( of: refined, to: query, model: model, directory: directory)) #expect(refinedSim >= seedSim - 1e-4) print("inversion sim: seed \(seedSim) → refined \(refinedSim)") } /// Creating ORT sessions on several threads at once used to segfault inside /// the graph transformer (global op-schema registry isn't thread-safe). /// With the creation lock this must complete cleanly. @Test("Concurrent ORT session creation is safe") func concurrentSessions() async throws { let d = Self.modelsDirectory let files = [ "stylegan2-ffhq-synth.onnx", "stylegan2-ffhq-map.onnx", "e4e-ffhq-encoder.onnx", "w600k_r50.onnx", "semantic-celeba-synth.onnx", ] let paths = files.map { d.appendingPathComponent($0).path } .filter { FileManager.default.fileExists(atPath: $0) } guard paths.count >= 3 else { return } await withTaskGroup(of: Bool.self) { group in for path in paths { group.addTask { (try? ORTSession(modelPath: path, useCoreML: false)) != nil } } var ok = 0 for await made in group where made { ok += 1 } #expect(ok == paths.count) // reaching here without crashing is the point } } /// Encoder inversion end-to-end: encode a generated face to W+, reconstruct /// via the W+ engine path, and confirm the identity is preserved (high /// ArcFace cosine). Skips if the encoder isn't staged. @Test("Encoder inversion reconstructs identity") func encoderInversion() async throws { let directory = Self.modelsDirectory let fm = FileManager.default guard fm.fileExists(atPath: directory.appendingPathComponent("e4e-ffhq-encoder.onnx").path) else { return } let model = try #require(LocalFaceModel.find("local/stylegan2-ffhq")) let png = try await FaceLocalEngine.shared.png( model: model, directory: directory, latent: FaceLocalEngine.gaussianLatent(seed: 123)) // Fresh CIImage per actor call so none is reused after being sent. let forEncode = try #require(CIImage(data: png)) let wplus = try #require( await FaceInversion.shared.encodeWPlus(forEncode, directory: directory)) #expect(wplus.count == 18 * 512) let recon = try await FaceLocalEngine.shared.png( model: model, directory: directory, wplus: wplus) let forArcOriginal = try #require(CIImage(data: png)) let forArcRecon = try #require(CIImage(data: recon)) let a = try #require( await FaceInversion.shared.embedDropped(forArcOriginal, directory: directory)) let b = try #require( await FaceInversion.shared.embedDropped(forArcRecon, directory: directory)) var sim: Float = 0 for i in 0.. 0.5) } /// Offline generator for the precomputed nearest-neighbour banks shipped in /// the bundle. Not part of the normal suite — run explicitly: /// FACEMAKER_BUILD_BANKS=1 make test /// Writes models/bank-.bin for every generator (build.sh bundles them). @Test("Generate bundled banks", .enabled(if: ProcessInfo.processInfo.environment["FACEMAKER_BUILD_BANKS"] == "1")) func generateBanks() async throws { let directory = Self.modelsDirectory let target = 200 for model in LocalFaceModel.all { let out = directory.appendingPathComponent( "bank-\(model.id.replacingOccurrences(of: "/", with: "_")).bin") // Resumable: a complete bank file already on disk is left alone. if FileManager.default.fileExists(atPath: out.path) { print("[\(model.id)] already built — skipping") continue } let clock = ContinuousClock() let elapsed = try await clock.measure { try await FaceInversion.shared.exportBank( model: model, directory: directory, target: target, to: out, progress: { done, total in if done % 25 == 0 || done == total { print("[\(model.id)] \(done)/\(total)") } }) } print("[\(model.id)] wrote \(out.lastPathComponent) in \(elapsed)") #expect(FileManager.default.fileExists(atPath: out.path)) } } @Test("Model catalog loads and sorts by speed") func catalog() { let models = LocalFaceModel.all #expect(!models.isEmpty) #expect(LocalFaceModel.fastest.id == "local/mobilestylegan-ffhq") #expect(LocalFaceModel.find("local/stylegan2-ffhq") != nil) } @Test("Prompt brief formats non-neutral edits") func brief() { #expect(FacePrompt.localBrief([]) == "Face.") let brief = FacePrompt.localBrief([("Age", 2.0)]) #expect(brief.contains("Age")) } }