File size: 6,593 Bytes
73e516d f30809a 73e516d f30809a 73e516d 60ca02b f30809a 60ca02b f30809a 73e516d 615d011 6059d43 615d011 6059d43 615d011 6059d43 615d011 6059d43 615d011 6059d43 615d011 f30809a |
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 181 182 183 184 185 |
---
base_model: [meta-llama/Meta-Llama-3-70B-Instruct]
merge_model: [NousResearch/Hermes-2-Pro-Llama-3-70B]
library_name: transformers
tags:
- mergekit
- merge
license: llama3
---
### Yoloing this 99-layer llamastein straight to the leaderboard wish me luck
> [!TIP]
>for 1bit quant download:
>
```bash
wget https://huggingface.co/nisten/llamagnific-3-87b-gguf/resolve/main/llamagnific_1bit_optimized_IQ1_L.gguf
```
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 faster 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.
``` |