Upload 3 files

README.md

@@ -1,13 +1,54 @@
----
-title: Flutter Code Generator
-emoji: 📚
-colorFrom: blue
-colorTo: purple
-sdk: streamlit
-sdk_version: 1.40.2
-app_file: app.py
-pinned: false
-license: mit
+
+# Flutter Code Generator - Hugging Face Space
+
+This project leverages Transformers and Hugging Face's Spaces to generate Flutter code based on user prompts. It is designed to simplify Flutter development by providing intelligent suggestions for UI and functionality implementations.
+
+## Features
+- **Customizable Flutter Code Generation**: Enter prompts like "Create a responsive login screen" to get Dart code snippets.
+- **Streamlit Web App**: Interactive UI for generating Flutter code with adjustable parameters.
+- **Fine-tuned Model**: Trained on multiple datasets for Flutter-specific code generation.
+
+## Installation
+To run the app locally, follow these steps:
+
+### Clone the Repository
+```bash
+git clone https://github.com/cod-e-codes/flutter-code-generator.git
+cd flutter-code-generator
+```
+
+### Install Dependencies
+```bash
+pip install -r requirements.txt
+```
+
+### Run the Streamlit App
+```bash
+streamlit run app.py
+```
+
+## Parameters
+Adjust the following settings via the sidebar for code generation:
+- **Temperature**: Controls randomness (higher = more random outputs).
+- **Top-p**: Cumulative probability for nucleus sampling.
+- **Max Length**: Maximum tokens in output.
+- **Repetition Penalty**: Penalizes repetitive text.
+- **Top-k**: Limits the sampling pool.
+
+## Deploying to Hugging Face Spaces
+1. Create a Hugging Face Space and select the "Streamlit" template.
+2. Upload the code files from this repository.
+3. Configure the environment by adding the required packages.
+4. Deploy and access the app via your Space's URL.
+
+## Model Training
+The model was fine-tuned using:
+- Datasets from Hugging Face such as `wraps/codegen-flutter-v1`, `limcheekin/flutter-website-3.7`, and `deepklarity/top-flutter-packages`.
+- A checkpoint from Salesforce's CodeGen model (`codegen-350M-mono`).
+
+## License
+This project is open-source and available under the [MIT License](LICENSE).
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Built with ❤️ by [Cod-e-Codes](https://github.com/cod-e-codes)

app.py

@@ -0,0 +1,115 @@
+import streamlit as st
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+# Load pre-trained model and tokenizer from the checkpoint
+model_name = "./flutter_codegen_model/checkpoint-1500"
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+tokenizer.pad_token = tokenizer.eos_token
+model = AutoModelForCausalLM.from_pretrained(model_name)
+
+# Function to clean up repetitive lines in code
+def clean_code_response(response):
+    lines = response.splitlines()
+    unique_lines = []
+    for line in lines:
+        if line.strip() not in unique_lines:  # Avoid duplicates
+            unique_lines.append(line.strip())
+    return "\n".join(unique_lines)
+
+# Function to generate Flutter code
+def generate_flutter_code(prompt, temperature, top_p, max_length, num_return_sequences, repetition_penalty, top_k):
+    inputs = tokenizer(
+        prompt,
+        return_tensors="pt",
+        padding=True,
+        truncation=True,
+    )
+    outputs = model.generate(
+        inputs["input_ids"],
+        max_length=max_length,
+        num_return_sequences=num_return_sequences,
+        temperature=temperature,
+        top_p=top_p,
+        top_k=top_k,
+        repetition_penalty=repetition_penalty,
+        do_sample=True,
+        pad_token_id=tokenizer.pad_token_id,
+    )
+    code = [tokenizer.decode(output, skip_special_tokens=True) for output in outputs]
+    return [clean_code_response(c) for c in code]
+
+# App Title
+st.title("Flutter Code Generator")
+
+# Default parameter values
+DEFAULT_TEMPERATURE = 0.7
+DEFAULT_TOP_P = 0.9
+DEFAULT_MAX_LENGTH = 512
+DEFAULT_NUM_RETURN_SEQUENCES = 1
+DEFAULT_REPETITION_PENALTY = 1.2
+DEFAULT_TOP_K = 50
+
+# Sidebar for settings
+st.sidebar.title("Generation Settings")
+
+temperature = st.sidebar.slider(
+    "Temperature (randomness)",
+    0.1, 1.0, DEFAULT_TEMPERATURE, step=0.1,
+)
+
+top_p = st.sidebar.slider(
+    "Top-p (cumulative probability)",
+    0.1, 1.0, DEFAULT_TOP_P, step=0.1,
+)
+
+max_length = st.sidebar.slider(
+    "Max Output Length (tokens)",
+    128, 1024, DEFAULT_MAX_LENGTH, step=64,
+)
+
+num_return_sequences = st.sidebar.slider(
+    "Number of Outputs",
+    1, 5, DEFAULT_NUM_RETURN_SEQUENCES,
+)
+
+repetition_penalty = st.sidebar.slider(
+    "Repetition Penalty",
+    1.0, 2.0, DEFAULT_REPETITION_PENALTY, step=0.1,
+)
+
+top_k = st.sidebar.slider(
+    "Top-k (limit sampling pool)",
+    0, 100, DEFAULT_TOP_K,
+)
+
+# Reset to defaults button
+if st.sidebar.button("Reset to Defaults"):
+    st.session_state.update(
+        {
+            "temperature": DEFAULT_TEMPERATURE,
+            "top_p": DEFAULT_TOP_P,
+            "max_length": DEFAULT_MAX_LENGTH,
+            "num_return_sequences": DEFAULT_NUM_RETURN_SEQUENCES,
+            "repetition_penalty": DEFAULT_REPETITION_PENALTY,
+            "top_k": DEFAULT_TOP_K,
+        }
+    )
+
+# Input Section
+user_input = st.text_area(
+    "Enter your prompt (e.g., 'Create a responsive login screen'):",
+    max_chars=200,
+)
+
+# Output Section
+if st.button("Generate Code"):
+    if user_input.strip():
+        prompt = f"{user_input.strip()}"
+        generated_code = generate_flutter_code(
+            prompt, temperature, top_p, max_length, num_return_sequences, repetition_penalty, top_k
+        )
+        for i, code in enumerate(generated_code, start=1):
+            st.subheader(f"Output {i}")
+            st.code(code, language="dart")
+    else:
+        st.error("Please enter a prompt before clicking 'Generate Code'.")

train.py

@@ -0,0 +1,158 @@
+# from datasets import load_dataset
+# from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, Trainer
+# import torch
+
+# # Check for GPU
+# device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+# print(f"Using device: {device}")
+
+# # Step 1: Load the dataset
+# dataset = load_dataset("wraps/codegen-flutter-v1")
+
+# # Step 2: Load the tokenizer and model
+# model_name = "Salesforce/codegen-350M-mono"
+# tokenizer = AutoTokenizer.from_pretrained(model_name)
+# tokenizer.pad_token = tokenizer.eos_token  # Set the padding token
+# model = AutoModelForCausalLM.from_pretrained(model_name).to(device)
+
+# # Step 3: Tokenize the dataset
+# def tokenize_function(examples):
+#     return tokenizer(examples["content"], truncation=True, padding="max_length", max_length=512)
+
+# tokenized_dataset = dataset.map(tokenize_function, batched=True, remove_columns=["content"])
+
+# # Step 4: Set up training arguments
+# training_args = TrainingArguments(
+#     output_dir="./flutter_codegen_model",
+#     evaluation_strategy="epoch",
+#     learning_rate=5e-5,
+#     per_device_train_batch_size=4,  # Adjust based on GPU memory
+#     num_train_epochs=3,
+#     save_steps=500,
+#     save_total_limit=2,
+#     fp16=torch.cuda.is_available(),  # Use mixed precision if GPU is available
+#     logging_dir="./logs",
+#     logging_steps=10,
+#     report_to="none"
+# )
+
+# # Step 5: Initialize the Trainer
+# trainer = Trainer(
+#     model=model,
+#     args=training_args,
+#     train_dataset=tokenized_dataset["train"],
+#     eval_dataset=tokenized_dataset["validation"],
+#     tokenizer=tokenizer,
+# )
+
+# # Step 6: Train the model
+# trainer.train()
+
+# # Step 7: Save the fine-tuned model
+# model.save_pretrained("./flutter_codegen_model")
+# tokenizer.save_pretrained("./flutter_codegen_model")
+
+# # # # # # # # # # # # # # # # #
+#   Train on multiple datasets  #
+# # # # # # # # # # # # # # # # #
+
+from datasets import load_dataset, concatenate_datasets
+from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, Trainer
+import torch
+
+# Check for GPU
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(f"Using device: {device}")
+
+# Step 1: Load the datasets
+print("Loading datasets...")
+dataset1 = load_dataset("wraps/codegen-flutter-v1")
+dataset2 = load_dataset("limcheekin/flutter-website-3.7")
+dataset3 = load_dataset("deepklarity/top-flutter-packages")
+
+# Step 2: Preprocess datasets to extract relevant text
+def preprocess_dataset1(example):
+    return {"text": example["content"]}
+
+def preprocess_dataset2(example):
+    return {"text": example["text"]}
+
+def preprocess_dataset3(example):
+    # Combine title and description into one text entry
+    return {"text": f"{example['title']} - {example['description']}"}
+
+print("Preprocessing datasets...")
+dataset1_train = dataset1["train"].map(preprocess_dataset1, remove_columns=["repo_id", "file_path", "content", "__index_level_0__"])
+dataset2_train = dataset2["train"].map(preprocess_dataset2, remove_columns=["id", "source"])
+dataset3_train = dataset3["train"].map(preprocess_dataset3, remove_columns=["title", "description", "likes", "dependencies"])
+
+# Combine all datasets into a single dataset
+print("Combining datasets...")
+combined_dataset = concatenate_datasets([dataset1_train, dataset2_train, dataset3_train])
+
+# Step 3: Create train-validation split
+print("Creating train-validation split...")
+train_test_split = combined_dataset.train_test_split(test_size=0.1, seed=42)
+train_dataset = train_test_split["train"]
+validation_dataset = train_test_split["test"]
+
+# Step 4: Load the tokenizer and model from the checkpoint
+print("Loading tokenizer and model from checkpoint...")
+checkpoint_path = "./flutter_codegen_model/checkpoint-1500"
+tokenizer = AutoTokenizer.from_pretrained(checkpoint_path)
+tokenizer.pad_token = tokenizer.eos_token  # Set the padding token
+model = AutoModelForCausalLM.from_pretrained(checkpoint_path).to(device)
+
+# Step 5: Tokenize the datasets
+def tokenize_function(examples):
+    # Tokenize the text and add labels
+    tokenized = tokenizer(
+        examples["text"],
+        truncation=True,
+        padding="max_length",
+        max_length=512,
+    )
+    tokenized["labels"] = tokenized["input_ids"].copy()  # Duplicate input_ids as labels
+    return tokenized
+
+print("Tokenizing datasets...")
+tokenized_train_dataset = train_dataset.map(tokenize_function, batched=True, remove_columns=["text"])
+tokenized_validation_dataset = validation_dataset.map(tokenize_function, batched=True, remove_columns=["text"])
+
+# Step 6: Set up training arguments
+print("Setting up training arguments...")
+training_args = TrainingArguments(
+    output_dir="./flutter_codegen_model",
+    evaluation_strategy="epoch",
+    learning_rate=5e-5,
+    per_device_train_batch_size=4,  # Adjust based on GPU memory
+    num_train_epochs=3,
+    save_steps=500,
+    save_total_limit=2,
+    fp16=torch.cuda.is_available(),  # Use mixed precision if GPU is available
+    logging_dir="./logs",
+    logging_steps=10,
+    resume_from_checkpoint=checkpoint_path,  # Resume from the checkpoint
+    report_to="none"
+)
+
+# Step 7: Initialize the Trainer
+print("Initializing Trainer...")
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=tokenized_train_dataset,
+    eval_dataset=tokenized_validation_dataset,  # Use the new validation dataset
+    tokenizer=tokenizer,
+)
+
+# Step 8: Train the model
+print("Starting training from checkpoint...")
+trainer.train()
+
+# Step 9: Save the fine-tuned model
+print("Saving the model...")
+model.save_pretrained("./flutter_codegen_model")
+tokenizer.save_pretrained("./flutter_codegen_model")
+
+print("Training complete. Model saved to './flutter_codegen_model'.")