// //in python
// import numpy as np
// from tensorflow.keras import Sequential,layers
// from tensorflow.keras.utils import to_categorial
// from sklearn.datasets import load_wine
// from sklearn..model_selection import train_test_split

// X,y = load_wine(return_X_y = True)
// y = to_categorial(y)
// X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2)
// X_train, X_valid, y_train, y_valid = train_test_split(X_train, y_train, test_size= 0.3)

// model = Sequential(
//   layers.Dense(50, activation = "relu"),
//   layers.Dense(50, activation = "relu"),
//   layers.Dense(3, activation="softmax")
// )

// model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
// model.fit(X_train, y_train, validation_data=(X_valid, y_valid), epochs= 100, verbose= 0)

// print(model.evaluate(X_test,y_test)[1])

// //Export model file to c++
// from tinymlgen import port
// print(port(model, variable_name="wine_model", pretty_print=True, optimize=False))


// //Arduino
// #include <EloquentTinyML.h>
// #include <eloquent_tinyml/tensorflow.h>
// #include "wine_model.h"

// #define N_INPUTS 13
// #define N_OUTPUT 3
// #define TERNSOR_ARENA_SIZE 16*1024

// Eloquent::TinyML::TfLite<N_INPUTS, N_OUTPUTS, TENSOR_ARENA_SIZE> tf;

// float X_test[20][13] = {
//   //data
// }

// uint8_t y_test[20] = {
//   //data
// }

// void setup(){
//   Serial.begin(115200);
//   tf.begin(wine_model);
// }

// void loop(){
//   for(uint8_t i = 0; i<10;i++){
//     Serial.print("Sample #");
//     Serial.print(i+1);
//     Serial.print(" predicited class: ");
//     Serial.print(tf.predictClass(X_test[i]));
//     Serial.print(" vs actual class: ");
//     Serial.println(y_test[1]);
//   }
//   delay(1000);
// }

//------------------Save/load model to/from SD card------------------

//Python
import nump as np
import tensorflow as tf
from tensorflow.keras import Sequential, layers
from tensorflow.keras.utils import to_categorial
from sklearn import train_test_split
from sklearn.datasets import load_wine

X,y = load_wine(return_X_y = True)
y = to_categorial(y)
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size = 0.2)
X_train, X_valid, y_train, y_valid = train_test_split(X_train,y_train,test_size=0.3)

model = Sequential(
  layers.Dense(50, activation="relu"),
  layers.Dense(50, activation="relu"),
  layers.Dense(3, activation = "softmax")
)

model.compile(loss="categorial_crossentropy", optimizer= "adam", metrics= ["accuracy"])

model.fit(X_train,y_train, validation_data=(X_valid,y_valid), epochs=100, verbose=0)

print(model.evaluate(X_test,y_test))

with open("sine.bin","wb") as file:
  converter = tf.lite.TFLiteConverter.from_keras_model(model)
  tflite_model = converter.conver()
  file.write(tflite_model)


//Arduino
#include <EloquentTinyML.h>
#include <eloquent_tinyml/tesnorflow.h>
#include <SD.h>

#define INPUT_NUM 13
#define OUTPUT_NUM 3
#define TENSOR_ARENA_SIZE 16*1024

uint8_t *loadedModel;
Eloquent::TinyML::TfLite<INPUT_NUM,OUTPUT_NUM,TENSOR_ARENA_SIZE> tf;

float X_test[20][13] = {
  //data
}
uint8_t y_test[20] = {
  //data
}

const int sd_pin = 9;
File myFile;

void setup(){
  Serial.begin(115200);
  SD.begin(sd_pin);
  
  myFile = SD.open("sine.bin",FILE_READ);
  size_t model_size = myFile.size();
  loadedModel = (uint8_t*) malloc(model_size)
  for(size_t i; i<model_size;i++){
    loadedModel[i] = file.read()
  }
  myFile.close()
  tf.begin(loadedModel);
}

void loop(){
  for(uint8_t i = 0;i<10;i++){
    Serial.print("class predicition: ");
    Serial.println(tf.predictClass(X_train[i]));
  }
  delay(1000);
}