nisten/llamagnific-3-87b

The following is a very random experiment in mixing together the brains of 2 very different finetunes, llama3-70b-instruct, and nous-hermes-pro-70b which was not based on the instruct, but on the base mode, so these 2 models, are actually quite diverged from their common ancesotr, and honestly i wasnt expecting to work well at all, just yoloed it, there's still issues with hallucination due to prompt templates, but overall, end results were very surprising, it's both smart and tarded at once. Most surprising was the 1 bit quant qhich ended up being very coherent.

for 1bit quant download:

wget https://huggingface.co/nisten/llamagnific-3-87b-gguf/resolve/main/llamagnific_1bit_optimized_IQ1_L.gguf

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 faster with aria2

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

<|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.