func loadIrisDataset() -> (MLXArray, MLXArray, MLXArray, MLXArray)? {
   // Loading the file from the bundle
   guard let url = Bundle.main.url(forResource: "IrisDataset", withExtension: "csv") else {
      return nil
   }
   guard let content = try? String(contentsOf: url, encoding: .utf8) else {
      return nil
   }
   let lines = content.components(separatedBy: .newlines).filter { !$0.isEmpty }
   let dataRows = lines.dropFirst()

   var inputValues: [[Float32]] = []
   var targetValues: [Float32] = []
   for row in dataRows {
      let columns = row.split(separator: ",")
      var listValues: [Float32] = []

      for (index, value) in columns.enumerated() {
         if let x = Float32(value), index < 4 {
            listValues.append(x)
         } else if let target = Float32(value) {
            targetValues.append(target)
         }
      }
      inputValues.append(listValues)
   }
   // One-Hot Encoding the species
   let hotEncoding = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
   let targetHot = targetValues.map { hotEncoding[Int($0)] }

   // Getting random indexes for splitting data
   let indices = inputValues.indices.shuffled()
   let splitIndex = Int(Double(indices.count) * 0.75)

   // Split the data into training and testing
   let inputTraining = indices[..<splitIndex].map { inputValues[$0] }
   let inputTesting = indices[splitIndex...].map { inputValues[$0] }
   let targetTraining = indices[..<splitIndex].map { targetHot[$0] }
   let targetTesting = indices[splitIndex...].map { targetHot[$0] }

   // Convert to vectors we can use for MLXArray
   let inputTrainingFlat = inputTraining.flatMap { $0 }
   let inputTestingFlat = inputTesting.flatMap { $0 }
   let targetTrainingFlat = targetTraining.flatMap { $0 }
   let targetTestingFlat = targetTesting.flatMap { $0 }

   // Convert to MLXArray
   let inputTrainingArray = MLXArray(inputTrainingFlat, [inputTraining.count, 4])
   let inputTestingArray = MLXArray(inputTestingFlat, [inputTesting.count, 4])
   let targetTrainingArray = MLXArray(targetTrainingFlat, [targetTraining.count, 3])
   let targetTestingArray = MLXArray(targetTestingFlat, [targetTesting.count, 3])

   // Calculating values for normalization
   let mean = inputTrainingArray.mean(axes: [0], keepDims: false)
   let std = inputTrainingArray.variance(axes: [0], keepDims: false).sqrt()

   // Apply normalization to both training and testing data
   let eps: Float = 1e-6
   let stdSafe = std + eps
   let normalizedInputTraining = (inputTrainingArray - mean) / stdSafe
   let normalizedInputTesting = (inputTestingArray - mean) / stdSafe

   return (normalizedInputTraining, normalizedInputTesting, targetTrainingArray, targetTestingArray)
}