sample code for conversations added

README.md

@@ -48,6 +48,15 @@ A thrid LLM was fine-tuned using the above data.
 
 The `critic` and the `regenerator` was tested not only on the accopanying actor model, but 13B and 70B SynthIA models as well. They seem to be readily transferrable, as the function that it has learnt is to provide an intelligent critique and then a regeneration of the original response. Please feel free to try out other models as the `actor`. However, the architecture works best with all three as presented here in HelixNet.
 
+# Sample Generations
+
+![HelixNet](https://huggingface.co/migtissera/HelixNet/resolve/main/media/sample-answer.png)
+
+![HelixNet](https://huggingface.co/migtissera/HelixNet/resolve/main/media/sample-critique.png)
+
+![HelixNet](https://huggingface.co/migtissera/HelixNet/resolve/main/media/sample-regeneration.png)
+
+
 # Prompt format:
 
 ```
@@ -58,7 +67,7 @@ ASSISTANT:
 
 # Example Usage
 
-## Code example:
+## Code example (Verbose):
 
 The following is a code example on how to use HelixNet. No special system-context messages are needed for the `critic` and the `regenerator`.
 
@@ -141,8 +150,90 @@ while True:
 
 ```
 
-![HelixNet](https://huggingface.co/migtissera/HelixNet/resolve/main/media/sample-answer.png)
 
-![HelixNet](https://huggingface.co/migtissera/HelixNet/resolve/main/media/sample-critique.png)
 
-![HelixNet](https://huggingface.co/migtissera/HelixNet/resolve/main/media/sample-regeneration.png)
+## Code Example (Continuing a conversation)
+
+To have a back-and-forth conversation, only carry forward the system-context, questions and regenerations as shown below.
+
+```python
+import torch, json
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+model_path_actor = "/home/ubuntu/llm/HelixNet/actor"
+model_path_critic = "/home/ubuntu/llm/HelixNet/critic"
+model_path_regenerator = "/home/ubuntu/llm/HelixNet/regenerator"
+
+def load_model(model_path):
+    model = AutoModelForCausalLM.from_pretrained(
+        model_path,
+        torch_dtype=torch.float16,
+        device_map="cuda",
+        load_in_4bit=False,
+        trust_remote_code=True,
+    )
+    return model
+
+def load_tokenizer(model_path):
+    tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
+    return tokenizer
+
+model_actor = load_model(model_path_actor)
+model_critic = load_model(model_path_critic)
+model_regenerator = load_model(model_path_regenerator)
+
+tokenizer_actor = load_tokenizer(model_path_actor)
+tokenizer_critic = load_tokenizer(model_path_critic)
+tokenizer_regenerator = load_tokenizer(model_path_regenerator)
+
+def generate_text(instruction, model, tokenizer):
+    tokens = tokenizer.encode(instruction)
+    tokens = torch.LongTensor(tokens).unsqueeze(0)
+    tokens = tokens.to("cuda")
+
+    instance = {
+        "input_ids": tokens,
+        "top_p": 1.0,
+        "temperature": 0.75,
+        "generate_len": 1024,
+        "top_k": 50,
+    }
+
+    length = len(tokens[0])
+    with torch.no_grad():
+        rest = model.generate(
+            input_ids=tokens,
+            max_length=length + instance["generate_len"],
+            use_cache=True,
+            do_sample=True,
+            top_p=instance["top_p"],
+            temperature=instance["temperature"],
+            top_k=instance["top_k"],
+            num_return_sequences=1,
+        )
+    output = rest[0][length:]
+    string = tokenizer.decode(output, skip_special_tokens=True)
+    return f"{string}"
+
+system_prompt = "You are HelixNet. Elaborate on the topic using a Tree of Thoughts and backtrack when necessary to construct a clear, cohesive Chain of Thought reasoning. Always answer without hesitation."
+  
+conversation = f"SYSTEM:{system_prompt}"
+
+while True:
+    user_input = input("You: ")
+
+    prompt_actor = f"{conversation} \nUSER: {user_input} \nASSISTANT: "
+    actor_response = generate_text(prompt_actor, model_actor, tokenizer_actor)
+    print("Generated ACTOR RESPONSE")
+
+    prompt_critic = f"SYSTEM: {system_prompt} \nUSER: {user_input} \nRESPONSE: {actor_response} \nCRITIQUE:"
+    critic_response = generate_text(prompt_critic, model_critic, tokenizer_critic)
+    print("Generated CRITIQUE")
+
+    prompt_regenerator = f"SYSTEM: {system_prompt} \nUSER: {user_input} \nRESPONSE: {actor_response} \nCRITIQUE: {critic_response} \nREGENERATOR:"
+    regenerator_response = generate_text(prompt_regenerator, model_regenerator, tokenizer_regenerator)
+    print("Generated REGENERATION")
+
+    conversation = f"{conversation} \nUSER: {user_input} \nASSISTANT: {regenerator_response}"
+    print(conversation)
+```