|
--- |
|
base_model: [nisten/llamagnific-3-87b] |
|
merged_model: [NousResearch/Hermes-2-Pro-Llama-3-70B] |
|
|
|
library_name: transformers |
|
tags: |
|
- mergekit |
|
- merge |
|
license: llama3 |
|
--- |
|
GGUF Files of nisten/llamagnific-3-87b - a 99layer llama-3-70b frankenstein |
|
|
|
for fun use i recommend this file: |
|
|
|
```verilog |
|
wget https://huggingface.co/nisten/llamagnific-3-87b-gguf/resolve/main/llamagnific_OPTIMAL_IQ_4_XS.gguf |
|
``` |
|
if you're on linux you can download much fater with aria2 |
|
|
|
```verilog |
|
sudo apt install aria2 |
|
aria2c -x 8 -o llamagnific_OPTIMAL_IQ_4_XS.gguf https://huggingface.co/nisten/llamagnific-3-87b-gguf/resolve/main/llamagnific_OPTIMAL_IQ_4_XS.gguf |
|
``` |
|
make a prompt file named prompt.txt and put this in it |
|
|
|
```verilog |
|
<|im_start|>system{You are a hyperintelligent hilarious raccoon that solves everything via first-principles based resoning.}<|im_end|> |
|
<|im_start|>user{Careful this is a trick question. Think first then when done thinking say ...done_thinking... and answer correctly: 9.11 or 9.9, which is greater?} |
|
<|im_end|>assistant |
|
``` |
|
|
|
That's it that's your prompt template, to run it in conversaion do this (add -ngl 99 or less if you have a 24gb gpu, i.e. add -ngl 50 for a 16gb etc, the model itself is 98 layers so this determines how many layers you offload to gpu, by default its 0 ): |
|
|
|
```c |
|
./llama-cli --temp 0.4 -m llamagnific_OPTIMAL_IQ_4_XS.gguf -fa -co -cnv -i -f prompt.txt |
|
``` |
|
|
|
 |
|
|
|
|
|
# base_model: [meta-llama/Meta-Llama-3-70B-Instruct] |
|
# merge_model: [NousResearch/Hermes-2-Pro-Llama-3-70B] |
|
|
|
This is a merge of pre-trained language models created using [mergekit](https://github.com/cg123/mergekit). |
|
|
|
## Merge Details |
|
### Merge Method |
|
|
|
This model was merged using the passthrough merge method. |
|
|
|
### Models Merged |
|
|
|
The following models were included in the merge: |
|
* /home/admin/meta70 |
|
* /home/admin/hermes2pro |
|
|
|
### Configuration |
|
|
|
The following YAML configuration was used to produce this model: |
|
|
|
```yaml |
|
dtype: bfloat16 |
|
merge_method: passthrough |
|
slices: |
|
- sources: |
|
- layer_range: [0, 15] |
|
model: /home/admin/meta70 |
|
- sources: |
|
- layer_range: [10, 69] |
|
model: /home/admin/hermes2pro |
|
- sources: |
|
- layer_range: [55, 80] |
|
model: /home/admin/meta70 |
|
``` |
|
|
|
#TEST PROMPT IS LOOKING INTERESTING |
|
> [!TIP] |
|
> How to build a city on Mars? via aldrin cycler orbit shipments and calculate in assemblyscript some 64bit accurate orbits and shipments between 2025-2035 , output an actual table dont fluff. |
|
> |
|
|
|
```assembly |
|
Building a city on Mars is a complex and multi-faceted endeavor that requires a deep understanding of various fields, including orbital mechanics, materials science, and habitat design. Here's a high-level overview of the process, along with some AssemblyScript code to calculate 64-bit accurate orbits and shipments between 2025 and 2035. |
|
|
|
**Step 1: Orbital Mechanics and Aldrin Cycler** |
|
|
|
The Aldrin cycler is a type of spacecraft that uses a specific orbit to travel between Earth and Mars, making it an energy-efficient option for transporting people and cargo. The cycler's orbit is designed to have a synodic period (the time it takes to complete one round trip) of approximately 2.14 years, which is close to the Earth-Mars synodic period. |
|
|
|
To calculate the cycler's orbit, we'll use the vis-viva equation, which relates the orbital velocity of a spacecraft to its position and the central body's gravitational parameter (μ). The equation is: |
|
|
|
v = sqrt(μ \* (2/r - 1/a)) |
|
|
|
where: |
|
v = orbital velocity |
|
μ = standard gravitational parameter (for Earth, μ = 3.986004418e+14 m³/s²) |
|
r = position vector (distance from the central body) |
|
a = semi-major axis of the orbit |
|
|
|
Here's an AssemblyScript function to calculate the cycler's orbit: |
|
|
|
|
|
(import "env" "console_log" (func $console_log (result i32) (i32))) |
|
|
|
(memory (import "env" "memory") 1) |
|
|
|
(data (i32.const 0) "\0A\00\00\00") |
|
|
|
@; Calculate the cycler's orbit |
|
@; Args: r (f64) - position vector (distance from the central body) |
|
@; a (f64) - semi-major axis of the orbit |
|
@; Returns: v (f64) - orbital velocity |
|
(func $cycler_orbit (param $r f64) (param $a f64) (result f64) |
|
(f64.mul |
|
(f64.const 3.986004418e+14) |
|
(f64.sub |
|
(f64.div |
|
(f64.const 2) |
|
(f64.copy $r) |
|
) |
|
(f64.div |
|
(f64.const 1) |
|
(f64.copy $a) |
|
) |
|
) |
|
) |
|
) |
|
|
|
@; Example usage: Calculate the cycler's velocity at a position of 1.5 AU |
|
@; (1 AU = 1.496e+11 m) and a semi-major axis of 2.4 AU |
|
(f64.print |
|
(call $cycler_orbit |
|
(f64.mul (f64.const 1.5) (f64.const 1.496e+11)) |
|
(f64.mul (f64.const 2.4) (f64.const 1.496e+11))) |
|
) |
|
) |
|
|
|
|
|
**Step 2: Assembly and Construction** |
|
|
|
Once you've calculated the cycler's orbit, you'll need to assemble and construct the city on Mars. This will involve designing habitats, life support systems, and infrastructure to support human habitation. |
|
|
|
**Step 3: Table of Shipments** |
|
|
|
To create a table of shipments between 2025 and 2035, you'll need to determine the number of cyclers, the cargo capacity of each cycler, and the frequency of shipments. Here's a simple AssemblyScript function to calculate the total cargo capacity over a given period: |
|
|
|
|
|
@; Calculate the total cargo capacity over a given period |
|
@; Args: num_cyclers (i64) - number of cyclers |
|
@; cargo_capacity (f64) - cargo capacity of each cycler (in tons) |
|
@; start_year (i64) - start year (e.g., 2025) |
|
@; end_year (i64) - end year (e.g., 2035) |
|
@; Returns: total_capacity (f64) - total cargo capacity (in tons) |
|
(func $total_cargo_capacity (param $num_cyclers i64) (param $cargo_capacity f64) (param $start_year i64) (param $end_year i64) (result f64) |
|
(f64.mul |
|
(f64.conv_i64_f64 |
|
(i64.sub |
|
(get_local $end_year) |
|
(get_local $start_year) |
|
) |
|
) |
|
(f64.conv_i64_f64 |
|
(get_local $num_cyclers) |
|
) |
|
(f64.copy $cargo_capacity) |
|
) |
|
) |
|
|
|
@; Example usage: Calculate the total cargo capacity for 2 cyclers with a capacity of 500 tons each, between 2025 and 2035 |
|
(f64.print |
|
(call $total_cargo_capacity |
|
(i64.const 2) |
|
(f64.const 500) |
|
(i64.const 2025) |
|
(i64.const 2035) |
|
) |
|
) |
|
|
|
|
|
This is a high-level overview of the process, and there are many more details to consider when building a city on Mars. However, this should give you a starting point for understanding the orbital mechanics and assembly aspects of the project. |
|
``` |
