Create README.md

README.md

@@ -0,0 +1,109 @@
+# Model Card: T5-Base Fine-Tuned for Recipe Direction Generation (FP16)
+**Model Overview**
+- **Model Name:** t5-base-recipe-finetuned-fp16
+- **Model Type:** Sequence-to-Sequence Transformer
+- **Base Model:** google/t5-base (220M parameters)
+- **Quantization:** FP16 (half-precision floating-point)
+- **Task:** Generate cooking directions from a list of ingredients
+
+**Intended Use**
+- This model is designed to generate step-by-step cooking directions given a list of ingredients. It’s intended for:
+- Recipe creation assistance.
+- Educational purposes in culinary AI research.
+- Exploration of text-to-text generation in domain-specific tasks.
+- Primary Users: Home cooks, recipe developers, AI researchers.
+
+
+# Model Details
+- **Architecture:** T5 (Text-to-Text Transfer Transformer), encoder-decoder Transformer with 12 layers, 768 hidden size, 12 attention heads.
+- **Input:** Text string in the format "generate recipe directions from ingredients: <ingredient1> <ingredient2> ...".
+- **Output:** Text string containing cooking directions.
+- **Quantization:** Converted to FP16 for reduced memory usage (~425 MB vs. ~850 MB in FP32) and faster inference on GPU.
+- **Hardware:** Fine-tuned and tested on a 12 GB NVIDIA GPU with CUDA.
+# Training Data
+- **Dataset:** RecipeNLG
+- **Source:** Publicly available recipe dataset (downloaded as CSV)
+- **Size:** 2,231,142 examples (original); subset of 178,491 used for training (10% of train split)
+# Splits:
+- **Train:** 178,491 examples (subset)
+- **Validation:** 223,114 examples
+- **Test:** 223,115 examples
+- **Attributes:** ingredients (list of ingredients), directions (list of steps)
+- **Preprocessing:** Converted stringified lists to text; input prefixed with "generate recipe directions from ingredients: ".
+
+# Training Procedure
+**Framework:** Hugging Face Transformers
+**Hyperparameters:**
+Epochs: 1 (subset training; full training planned for 3 epochs)
+Effective Batch Size: 32 (8 per device, 4 gradient accumulation steps)
+Learning Rate: 2e-5
+Optimizer: AdamW (default in Trainer)
+Mixed Precision: FP16 (fp16=True)
+Training Time: ~2.3 hours estimated for subset (1 epoch); full dataset (3 epochs) estimated at ~68 hours per epoch without optimization.
+Compute: Single 12 GB GPU (NVIDIA, CUDA-enabled).
+Evaluation
+Metrics: Loss (to be filled post-training)
+Validation Loss: [TBD after training]
+Test Loss: [TBD after evaluation]
+Method: Evaluated using Trainer.evaluate() on validation and test splits.
+Qualitative: Generated directions checked for coherence with input ingredients (e.g., chicken and rice input should yield relevant steps).
+Performance
+Results: [TBD; e.g., "Validation Loss: X.XX, Test Loss: Y.YY after 1 epoch on subset"]
+Strengths: Expected to generate plausible directions for common ingredient combinations.
+Limitations:
+Limited training on subset may reduce generalization.
+Sporadic data mismatches may affect output quality.
+FP16 quantization might slightly alter precision vs. FP32.
+Usage
+Installation
+bash
+
+Collapse
+
+Wrap
+
+Copy
+pip install transformers torch datasets
+Inference Example
+python
+
+Collapse
+
+Wrap
+
+Copy
+from transformers import T5Tokenizer, T5ForConditionalGeneration
+import torch
+
+model_path = "./t5_recipe_finetuned_fp16"
+tokenizer = T5Tokenizer.from_pretrained(model_path)
+model = T5ForConditionalGeneration.from_pretrained(model_path).to("cuda").half()
+
+ingredients = ["1 lb chicken breast", "2 cups rice", "1 onion", "2 tbsp soy sauce"]
+input_text = "generate recipe directions from ingredients: " + " ".join(ingredients)
+input_ids = tokenizer(input_text, return_tensors="pt", max_length=128, truncation=True).input_ids.to("cuda")
+
+model.eval()
+with torch.no_grad():
+    output_ids = model.generate(input_ids, max_length=256, num_beams=4, early_stopping=True, no_repeat_ngram_size=2)
+directions = tokenizer.decode(output_ids[0], skip_special_tokens=True)
+print(directions)
+Saved Model
+Location: ./t5_recipe_finetuned_fp16
+Size: ~425 MB (FP16 weights)
+Limitations and Biases
+Data Quality: Some RecipeNLG entries have mismatched ingredients and directions, potentially leading to nonsensical outputs.
+Scope: Trained only on English recipes; may not handle non-English inputs or exotic cuisines well.
+Bias: Reflects biases in RecipeNLG (e.g., Western cuisine dominance).
+Quantization: FP16 may introduce minor numerical differences vs. FP32, though mitigated by FP16 training.
+Ethical Considerations
+Use: Should not be used to replace professional culinary expertise without validation.
+Safety: Generated directions aren’t guaranteed to be safe or accurate (e.g., cooking times, temperatures).
+Contact
+Author: [Your Name/Group Name]
+Support: [Your Email/GitHub, if applicable]
+Citation
+If you use this model, please cite:
+
+RecipeNLG dataset: [Add citation if available]
+T5: Raffel et al., "Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer" (2020)