Upload 9 files

README.md

@@ -1,11 +1,202 @@
 ---
-title: Neon 8 Qubits
-emoji: 📚
-colorFrom: purple
-colorTo: indigo
-sdk: docker
-pinned: false
+library_name: transformers
 license: mit
+language:
+- en
+pipeline_tag: text-generation
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Model Card for Model ID
+
+<!-- Provide a quick summary of what the model is/does. -->
+
+
+
+## Model Details
+
+### Model Description
+
+<!-- Provide a longer summary of what this model is. -->
+
+This is the model card of a 🤗 transformers model that has been pushed on the Hub. This model card has been automatically generated.
+
+- **Developed by:** [More Information Needed]
+- **Funded by [optional]:** [More Information Needed]
+- **Shared by [optional]:** [More Information Needed]
+- **Model type:** [More Information Needed]
+- **Language(s) (NLP):** [More Information Needed]
+- **License:** [More Information Needed]
+- **Finetuned from model [optional]:** [More Information Needed]
+
+### Model Sources [optional]
+
+<!-- Provide the basic links for the model. -->
+
+- **Repository:** [More Information Needed]
+- **Paper [optional]:** [More Information Needed]
+- **Demo [optional]:** [More Information Needed]
+
+## Uses
+
+<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+
+### Direct Use
+
+<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+
+[More Information Needed]
+
+### Downstream Use [optional]
+
+<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+
+[More Information Needed]
+
+### Out-of-Scope Use
+
+<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+
+[More Information Needed]
+
+## Bias, Risks, and Limitations
+
+<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+
+[More Information Needed]
+
+### Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+[More Information Needed]
+
+## Training Details
+
+### Training Data
+
+<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+
+[More Information Needed]
+
+### Training Procedure
+
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+
+#### Preprocessing [optional]
+
+[More Information Needed]
+
+
+#### Training Hyperparameters
+
+- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+
+#### Speeds, Sizes, Times [optional]
+
+<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+
+[More Information Needed]
+
+## Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+<!-- This should link to a Dataset Card if possible. -->
+
+[More Information Needed]
+
+#### Factors
+
+<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+
+[More Information Needed]
+
+#### Metrics
+
+<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+
+[More Information Needed]
+
+### Results
+
+[More Information Needed]
+
+#### Summary
+
+
+
+## Model Examination [optional]
+
+<!-- Relevant interpretability work for the model goes here -->
+
+[More Information Needed]
+
+## Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** [More Information Needed]
+- **Hours used:** [More Information Needed]
+- **Cloud Provider:** [More Information Needed]
+- **Compute Region:** [More Information Needed]
+- **Carbon Emitted:** [More Information Needed]
+
+## Technical Specifications [optional]
+
+### Model Architecture and Objective
+
+[More Information Needed]
+
+### Compute Infrastructure
+
+[More Information Needed]
+
+#### Hardware
+
+[More Information Needed]
+
+#### Software
+
+[More Information Needed]
+
+## Citation [optional]
+
+<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+[More Information Needed]
+
+**APA:**
+
+[More Information Needed]
+
+## Glossary [optional]
+
+<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+
+[More Information Needed]
+
+## More Information [optional]
+
+[More Information Needed]
+
+## Model Card Authors [optional]
+
+[More Information Needed]
+
+## Model Card Contact
+
+[More Information Needed]

config.json

@@ -0,0 +1,13 @@
+{
+  "architectures": [
+    "HuggingFaceGPTModel"
+  ],
+  "block_size": 1024,
+  "hidden_size": 1024,
+  "model_type": "custom_gpt",
+  "n_head": 16,
+  "n_layer": 24,
+  "torch_dtype": "float32",
+  "transformers_version": "4.44.2",
+  "vocab_size": 50304
+}

custom_gpt_config.py

@@ -0,0 +1,19 @@
+from transformers import GPT2Config
+from transformers.models.auto.configuration_auto import CONFIG_MAPPING
+
+class CustomGPTConfig(GPT2Config):
+    model_type = "custom_gpt"
+
+    def __init__(self, vocab_size=50304, n_layer=24, n_head=16, hidden_size=1024, block_size=1024, **kwargs):
+        super().__init__(
+            vocab_size=vocab_size,
+            n_positions=block_size,
+            n_ctx=block_size,
+            n_embd=hidden_size,
+            n_layer=n_layer,
+            n_head=n_head,
+            **kwargs,
+        )
+
+# Register the custom configuration
+CONFIG_MAPPING.register("custom_gpt", CustomGPTConfig)

handler.py

@@ -0,0 +1,131 @@
+import torch
+import torch.nn.functional as F
+from transformers import GPT2Tokenizer, PreTrainedModel, PretrainedConfig
+
+# Custom Configuration
+from transformers import GPT2Config
+from transformers.models.auto.configuration_auto import CONFIG_MAPPING
+
+
+class CustomGPTConfig(GPT2Config):
+    model_type = "custom_gpt"
+
+    def __init__(self, vocab_size=50304, n_layer=24, n_head=16, hidden_size=1024, block_size=1024, **kwargs):
+        super().__init__(
+            vocab_size=vocab_size,
+            n_positions=block_size,
+            n_ctx=block_size,
+            n_embd=hidden_size,
+            n_layer=n_layer,
+            n_head=n_head,
+            **kwargs,
+        )
+        self.block_size = block_size  # Ensure block_size is properly set
+
+
+# Register the custom configuration
+CONFIG_MAPPING.register("custom_gpt", CustomGPTConfig)
+
+
+# Wrapper for GPT to make it compatible with HF中国镜像站
+class HuggingFaceGPT(PreTrainedModel):
+    config_class = CustomGPTConfig
+
+    def __init__(self, config):
+        super().__init__(config)
+        from nova_model import GPT  # Replace with your actual model import
+        self.transformer = GPT(config)
+
+    def forward(self, input_ids, **kwargs):
+        targets = kwargs.get("labels", None)
+        logits, loss = self.transformer(input_ids, targets=targets)
+        return {"logits": logits, "loss": loss}
+
+
+class EndpointHandler:
+    def __init__(self, model_dir, device="cuda"):
+        print(f"Initializing model from directory: {model_dir}")
+        # Load custom configuration and model
+        self.config = CustomGPTConfig.from_pretrained(model_dir)
+        self.model = HuggingFaceGPT(self.config)
+        state_dict = torch.load(f"{model_dir}/pytorch_model.bin", map_location=torch.device(device))
+        self.model.load_state_dict(state_dict)
+        self.model.to(device)
+        self.model.eval()
+        print("Model initialized successfully.")
+
+        # Load tokenizer
+        self.tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
+        self.device = device
+        print("Tokenizer loaded successfully.")
+
+    def __call__(self, inputs):
+        print("Processing inputs...")
+        # Extract inputs
+        prompt = inputs.get("inputs", "")
+        parameters = inputs.get("parameters", {})
+        max_length = parameters.get("max_length", 32)
+        num_return_sequences = parameters.get("num_return_sequences", 4)
+        temperature = parameters.get("temperature", 1.0)
+        top_k = parameters.get("top_k", 50)
+
+        if not prompt:
+            print("Error: Input prompt is missing.")
+            return [{"error": "Input prompt is missing"}]
+
+        print(f"Prompt: {prompt}")
+        print(f"Parameters: {parameters}")
+
+        # Encode input prompt
+        tokens = self.tokenizer.encode(prompt, return_tensors="pt").to(self.device)
+        tokens = tokens.repeat(num_return_sequences, 1)
+
+        # Prepare RNG for reproducibility
+        sample_rng = torch.Generator(device=self.device)
+        sample_rng.manual_seed(42)
+
+        # Initialize generation
+        generated_tokens = tokens
+        while generated_tokens.size(1) < max_length:
+            with torch.no_grad():
+                # Forward pass to get logits
+                output = self.model(input_ids=generated_tokens)
+                logits = output["logits"][:, -1, :]  # Get the last token logits
+
+                # Apply softmax to get probabilities
+                probs = F.softmax(logits / temperature, dim=-1)
+
+                # Top-k sampling
+                topk_probs, topk_indices = torch.topk(probs, top_k, dim=-1)
+                next_token = torch.multinomial(topk_probs, 1, generator=sample_rng)
+                selected_token = torch.gather(topk_indices, -1, next_token)
+
+                # Append the generated token
+                generated_tokens = torch.cat((generated_tokens, selected_token), dim=1)
+
+                # Debug log for generation progress
+                print(f"Generated tokens so far: {generated_tokens.size(1)}/{max_length}")
+
+        # Decode and return generated text
+        results = []
+        for i in range(num_return_sequences):
+            tokens_list = generated_tokens[i, :max_length].tolist()
+            decoded_text = self.tokenizer.decode(tokens_list, skip_special_tokens=True)
+            results.append({"generated_text": decoded_text})
+
+        print("Generation completed.")
+        return results
+
+
+if __name__ == "__main__":
+    # Example usage
+    model_directory = "./"
+    handler = EndpointHandler(model_directory)
+
+    prompt_text = "Hello, I'm a language model,"
+    inputs = {"inputs": prompt_text, "parameters": {"max_length": 32, "num_return_sequences": 4, "temperature": 0.7, "top_k": 50}}
+
+    print("Starting inference...")
+    outputs = handler(inputs)
+    for idx, result in enumerate(outputs):
+        print(f"Sample {idx}: {result['generated_text']}")

nova_model.py

@@ -0,0 +1,131 @@
+import torch
+import torch.nn as nn
+from torch.nn import functional as F
+from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap, ZFeatureMap
+from qiskit import QuantumCircuit
+from qiskit_machine_learning.neural_networks import SamplerQNN
+from qiskit_machine_learning.connectors import TorchConnector
+from dataclasses import dataclass
+
+# Quantum Neural Network setup
+num_qubits = 8
+
+def create_qnn():
+    """Creates a Quantum Neural Network."""
+    feature_map = ZFeatureMap(num_qubits, reps=32)
+    ansatz = RealAmplitudes(num_qubits, reps=32)
+    qc = QuantumCircuit(num_qubits)
+    qc.compose(feature_map, inplace=True)
+    qc.compose(ansatz, inplace=True)
+
+    qnn = SamplerQNN(
+        circuit=qc,
+        input_params=feature_map.parameters,
+        weight_params=ansatz.parameters,
+    )
+
+    return qnn
+
+# Model Components
+class CausalSelfAttention(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        assert config.n_embd % config.n_head == 0
+        self.c_attn = nn.Linear(config.n_embd, 3 * config.n_embd)
+        self.c_proj = nn.Linear(config.n_embd, config.n_embd)
+        self.n_head = config.n_head
+        self.n_embd = config.n_embd
+
+    def forward(self, x):
+        B, T, C = x.size()  # Batch size, sequence length, embedding size
+        qkv = self.c_attn(x)
+        q, k, v = qkv.split(self.n_embd, dim=2)
+        k = k.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)
+        q = q.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)
+        v = v.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)
+        y = F.scaled_dot_product_attention(q, k, v, is_causal=True)
+        y = y.transpose(1, 2).contiguous().view(B, T, C)
+        y = self.c_proj(y)
+        return y
+
+class MLP(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.c_fc = nn.Linear(config.n_embd, 4 * config.n_embd)
+        self.gelu = nn.GELU(approximate='tanh')
+        self.c_proj = nn.Linear(4 * config.n_embd, config.n_embd)
+        self.quantum_embedding = nn.Linear(config.n_embd, num_qubits)
+        self.qnn_layer = TorchConnector(create_qnn())
+        self.output_layer = nn.Linear(2 ** num_qubits, 1024)
+
+    def forward(self, x):
+        x = self.quantum_embedding(x)
+        x = self.qnn_layer(x)
+        x = self.gelu(x)
+        x = self.output_layer(x)
+        return x
+
+class Block(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.ln_1 = nn.LayerNorm(config.n_embd)
+        self.attn = CausalSelfAttention(config)
+        self.ln_2 = nn.LayerNorm(config.n_embd)
+        self.mlp = MLP(config)
+
+    def forward(self, x):
+        x = x + self.attn(self.ln_1(x))
+        x = x + self.mlp(self.ln_2(x))
+        return x
+
+@dataclass
+class GPTConfig:
+    block_size: int = 1024
+    vocab_size: int = 50257
+    n_layer: int = 24
+    n_head: int = 16
+    n_embd: int = 1024
+
+class GPT(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.transformer = nn.ModuleDict(dict(
+            wte=nn.Embedding(config.vocab_size, config.n_embd),
+            wpe=nn.Embedding(config.block_size, config.n_embd),
+            h=nn.ModuleList([Block(config) for _ in range(config.n_layer)]),
+            ln_f=nn.LayerNorm(config.n_embd),
+        ))
+        self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False)
+        self.transformer.wte.weight = self.lm_head.weight
+        self.apply(self._init_weights)
+
+    def _init_weights(self, module):
+        if isinstance(module, nn.Linear):
+            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)
+            if module.bias is not None:
+                torch.nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.Embedding):
+            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)
+
+    def forward(self, idx, targets=None):
+        B, T = idx.size()
+        assert T <= self.config.block_size, "Sequence length exceeds block size"
+        pos = torch.arange(0, T, dtype=torch.long, device=idx.device)
+        tok_emb = self.transformer.wte(idx)
+        pos_emb = self.transformer.wpe(pos)
+        x = tok_emb + pos_emb
+        for block in self.transformer.h:
+            x = block(x)
+        x = self.transformer.ln_f(x)
+        logits = self.lm_head(x)
+        loss = None
+        if targets is not None:
+            loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1))
+        return logits, loss
+
+# Export the architecture for inference
+if __name__ == "__main__":
+    config = GPTConfig()
+    model = GPT(config)
+    print(f"Model architecture:\n{model}")

requirements.txt

@@ -0,0 +1,6 @@
+qiskit
+qiskit-machine-learning
+qiskit-aer-gpu
+transformers
+tiktoken
+datasets

special_tokens_map.json

@@ -0,0 +1,5 @@
+{
+  "bos_token": "<|endoftext|>",
+  "eos_token": "<|endoftext|>",
+  "unk_token": "<|endoftext|>"
+}