metadata
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:
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
sudo apt get 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
<|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 ):
./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.
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:
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
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.
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.