Core ML Transformer Modelleri Rehberi

1// Swift tarafinda donusturulmus BERT modelini yukleme
2import CoreML
3 
4class BERTModelLoader {
5    private var model: MLModel?
6 
7    func loadModel() throws {
8        let config = MLModelConfiguration()
9        config.computeUnits = .all
10 
11        // Compile edilmis modeli yukle
12        guard let modelURL = Bundle.main.url(
13            forResource: "DistilBERT",
14            withExtension: "mlmodelc"
15        ) else {
16            throw TransformerError.modelNotFound
17        }
18 
19        self.model = try MLModel(contentsOf: modelURL, configuration: config)
20    }
21 
22    func predict(inputIDs: MLMultiArray, attentionMask: MLMultiArray) throws -> MLMultiArray {
23        guard let model = model else {
24            throw TransformerError.modelNotLoaded
25        }
26 
27        let input = try MLDictionaryFeatureProvider(dictionary: [
28            "input_ids": MLFeatureValue(multiArray: inputIDs),
29            "attention_mask": MLFeatureValue(multiArray: attentionMask)
30        ])
31 
32        let output = try model.prediction(from: input)
33 
34        guard let logits = output.featureValue(for: "logits")?.multiArrayValue else {
35            throw TransformerError.predictionFailed
36        }
37 
38        return logits
39    }
40}
41 
42enum TransformerError: Error {
43    case modelNotFound
44    case modelNotLoaded
45    case predictionFailed
46    case tokenizationFailed
47}

1import CoreML
2 
3class BERTClassifier {
4    private let model: MLModel
5    private let tokenizer: BERTTokenizer
6    private let maxLength = 128
7 
8    init() throws {
9        let config = MLModelConfiguration()
10        config.computeUnits = .all
11 
12        guard let modelURL = Bundle.main.url(
13            forResource: "BERTClassifier",
14            withExtension: "mlmodelc"
15        ) else {
16            throw TransformerError.modelNotFound
17        }
18 
19        self.model = try MLModel(contentsOf: modelURL, configuration: config)
20        self.tokenizer = BERTTokenizer()
21    }
22 
23    func classify(text: String) throws -> ClassificationResult {
24        // Tokenization
25        let tokens = tokenizer.tokenize(text)
26        let inputIDs = try createMultiArray(from: tokens.inputIDs)
27        let attentionMask = try createMultiArray(from: tokens.attentionMask)
28 
29        // Prediction
30        let input = try MLDictionaryFeatureProvider(dictionary: [
31            "input_ids": MLFeatureValue(multiArray: inputIDs),
32            "attention_mask": MLFeatureValue(multiArray: attentionMask)
33        ])
34 
35        let output = try model.prediction(from: input)
36 
37        guard let logits = output.featureValue(for: "logits")?.multiArrayValue else {
38            throw TransformerError.predictionFailed
39        }
40 
41        // Softmax ve sonuc
42        let probabilities = softmax(logits)
43        let maxIndex = argmax(probabilities)
44 
45        return ClassificationResult(
46            label: labels[maxIndex],
47            confidence: probabilities[maxIndex]
48        )
49    }
50 
51    private func createMultiArray(from array: [Int]) throws -> MLMultiArray {
52        let mlArray = try MLMultiArray(shape: [1, NSNumber(value: maxLength)], dataType: .int32)
53        for (index, value) in array.prefix(maxLength).enumerated() {
54            mlArray[index] = NSNumber(value: value)
55        }
56        return mlArray
57    }
58 
59    private func softmax(_ logits: MLMultiArray) -> [Double] {
60        var values: [Double] = []
61        for i in 0..<logits.count {
62            values.append(logits[i].doubleValue)
63        }
64        let maxVal = values.max() ?? 0
65        let expValues = values.map { exp($0 - maxVal) }
66        let sumExp = expValues.reduce(0, +)
67        return expValues.map { $0 / sumExp }
68    }
69 
70    private func argmax(_ array: [Double]) -> Int {
71        var maxIdx = 0
72        var maxVal = array[0]
73        for (i, val) in array.enumerated() where val > maxVal {
74            maxVal = val
75            maxIdx = i
76        }
77        return maxIdx
78    }
79 
80    private let labels = ["Pozitif", "Negatif", "Notr"]
81}
82 
83struct ClassificationResult {
84    let label: String
85    let confidence: Double
86}

1class TextGenerator {
2    private let model: MLModel
3    private let tokenizer: GPT2Tokenizer
4 
5    func generate(
6        prompt: String,
7        maxTokens: Int = 100,
8        temperature: Double = 0.7,
9        topK: Int = 40
10    ) throws -> String {
11        var inputTokens = tokenizer.encode(prompt)
12        var generatedTokens: [Int] = []
13 
14        for _ in 0..<maxTokens {
15            let inputArray = try createInputArray(inputTokens)
16            let output = try model.prediction(from: inputArray)
17 
18            guard let logits = output.featureValue(for: "logits")?.multiArrayValue else {
19                break
20            }
21 
22            // Son token'in logit'lerini al
23            let lastLogits = extractLastTokenLogits(logits, seqLength: inputTokens.count)
24 
25            // Temperature scaling
26            let scaledLogits = lastLogits.map { $0 / temperature }
27 
28            // Top-K sampling
29            let nextToken = topKSample(scaledLogits, k: topK)
30 
31            // EOS token kontrolu
32            if nextToken == tokenizer.eosTokenID {
33                break
34            }
35 
36            generatedTokens.append(nextToken)
37            inputTokens.append(nextToken)
38        }
39 
40        return tokenizer.decode(generatedTokens)
41    }
42 
43    private func topKSample(_ logits: [Double], k: Int) -> Int {
44        let indexed = logits.enumerated().sorted { $0.element > $1.element }
45        let topK = Array(indexed.prefix(k))
46        let probs = softmax(topK.map { $0.element })
47 
48        // Weighted random sampling
49        let random = Double.random(in: 0..<1)
50        var cumulative = 0.0
51        for (i, prob) in probs.enumerated() {
52            cumulative += prob
53            if random < cumulative {
54                return topK[i].offset
55            }
56        }
57        return topK[0].offset
58    }
59 
60    private func softmax(_ values: [Double]) -> [Double] {
61        let maxVal = values.max() ?? 0
62        let expVals = values.map { exp($0 - maxVal) }
63        let sum = expVals.reduce(0, +)
64        return expVals.map { $0 / sum }
65    }
66 
67    private func extractLastTokenLogits(_ logits: MLMultiArray, seqLength: Int) -> [Double] {
68        // Implementation
69        return []
70    }
71 
72    private func createInputArray(_ tokens: [Int]) throws -> MLDictionaryFeatureProvider {
73        let array = try MLMultiArray(shape: [1, NSNumber(value: tokens.count)], dataType: .int32)
74        for (i, token) in tokens.enumerated() {
75            array[i] = NSNumber(value: token)
76        }
77        return try MLDictionaryFeatureProvider(dictionary: [
78            "input_ids": MLFeatureValue(multiArray: array)
79        ])
80    }
81}