File size: 7,142 Bytes
bd91486 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 | import torch
from torch import nn
from transformers import AutoModelForCausalLM, AutoTokenizer
from typing import Optional, Dict, Any
from datetime import datetime
from ..languages.generator import LanguageGenerator
class CogenBAI(nn.Module):
"""
CogenBAI: Advanced Code Generation Model
Created by Algo Science Academy
Lead Developer: Shahrear Hossain Shawon
Organization: Algo Science Academy
Academic Background: International Islamic University Chittagong
This model is designed to generate high-quality code across multiple programming
languages with support for various frameworks and coding patterns. It represents
a significant advancement in AI-assisted software development, combining modern
language support with intelligent code generation capabilities.
Copyright (c) 2024 Algo Science Academy
All rights reserved.
"""
# Model metadata
__author__ = "Shahrear Hossain Shawon"
__organization__ = "Algo Science Academy"
__version__ = "1.0.0"
__license__ = "Proprietary"
__copyright__ = f"Copyright (c) {datetime.now().year} Algo Science Academy"
__contact__ = {
"organization": "Algo Science Academy",
"developer": "Shahrear Hossain Shawon",
}
def __init__(self, model_name: str = "codegen-16B-multi", device: str = "cuda"):
"""
Initialize the CogenBAI model.
Developed by Algo Science Academy under the leadership of
Shahrear Hossain Shawon from International Islamic University Chittagong.
"""
super().__init__()
self.device = "cuda" if torch.cuda.is_available() and device == "cuda" else "cpu"
self.tokenizer = AutoTokenizer.from_pretrained(model_name)
self.model = AutoModelForCausalLM.from_pretrained(model_name).to(self.device)
self.lang_generator = LanguageGenerator()
self.project_tracker = ProjectTracker()
from ..languages.modern_frameworks import ModernFrameworkSupport
self.modern_frameworks = ModernFrameworkSupport()
@classmethod
def get_model_info(cls) -> Dict[str, Any]:
"""
Get information about the model and its creators.
"""
return {
"model_name": "CogenBAI",
"version": cls.__version__,
"author": cls.__author__,
"organization": cls.__organization__,
"institution": cls.__contact__["institution"],
"license": cls.__license__,
"copyright": cls.__copyright__,
"contact": cls.__contact__
}
def generate_code(self, prompt: str, language: str,
framework: Optional[str] = None,
max_length: int = 1024,
temperature: float = 0.7,
top_p: float = 0.95) -> str:
"""
Generate code based on the given prompt and parameters.
Args:
prompt (str): The coding task description
language (str): Target programming language
framework (Optional[str]): Specific framework to use
max_length (int): Maximum length of generated code
temperature (float): Sampling temperature
top_p (float): Nucleus sampling parameter
Returns:
str: Generated code
"""
# Validate language and framework
lang_config = self.lang_generator.get_language_config(language)
if not lang_config:
raise ValueError(f"Unsupported language: {language}")
if framework and framework not in lang_config["frameworks"]:
raise ValueError(f"Unsupported framework {framework} for {language}")
# Prepare prompt with language and framework context
context = f"Generate {language} code"
if framework:
context += f" using {framework}"
formatted_prompt = f"{context}:\n{prompt}\n\nSolution:\n"
# Generate code
inputs = self.tokenizer(formatted_prompt, return_tensors="pt").to(self.device)
outputs = self.model.generate(
inputs.input_ids,
max_length=max_length,
temperature=temperature,
top_p=top_p,
do_sample=True,
pad_token_id=self.tokenizer.eos_token_id,
num_return_sequences=1
)
generated_code = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
return self._format_code(generated_code, language)
def continue_project(self, project_id: str, new_feature_description: str) -> str:
"""Continue development of an existing project."""
project = self.project_tracker.get_project(project_id)
if not project:
raise ValueError(f"Project {project_id} not found")
# Generate context from existing code
context = self._build_project_context(project)
# Generate new code
new_code = self.generate_code(
prompt=f"{context}\n\nAdd feature: {new_feature_description}",
language=project.language,
framework=project.framework
)
# Update project state
project.code_snippets[new_feature_description] = new_code
project.last_modified = datetime.now()
self.project_tracker.update_project(project_id, {
"code_snippets": json.dumps(project.code_snippets),
"last_modified": project.last_modified.isoformat()
})
return new_code
def generate_deployment_config(self, project_id: str, platform: str) -> Dict[str, Any]:
"""Generate deployment configuration for modern frameworks."""
project = self.project_tracker.get_project(project_id)
if not project:
raise ValueError(f"Project {project_id} not found")
try:
deploy_config = self.modern_frameworks.get_deployment_config(
project.framework, platform
)
return deploy_config
except ValueError as e:
raise ValueError(f"Deployment configuration failed: {str(e)}")
def _build_project_context(self, project: ProjectState) -> str:
"""Build context from existing project code."""
context = f"Project: {project.name}\nLanguage: {project.language}\nFramework: {project.framework}\n\n"
context += "Existing code:\n"
for feature, code in project.code_snippets.items():
context += f"\n# Feature: {feature}\n{code}\n"
return context
def _format_code(self, code: str, language: str) -> str:
"""Format the generated code according to language standards."""
# Remove the prompt from the generated code
if "Solution:" in code:
code = code.split("Solution:")[-1].strip()
# Add language-specific formatting
if language == "python":
import black
try:
return black.format_str(code, mode=black.FileMode())
except:
return code
return code
|