ic

PINN/pinns.py

@@ -0,0 +1,53 @@
+from torch import nn,tensor
+import numpy as np
+import seaborn as sns
+class PINNd_p(nn.Module):
+    """ $d \mapsto P$
+
+    
+    """
+    def __init__(self):
+        super(PINNd_p,self).__init__()
+        weights = tensor([60.,0.5])
+        self.weights = nn.Parameter(weights)
+    def forward(self,x):
+        
+        c,b = self.weights
+        x1 = (x[0]/(c*x[1]))**0.5
+        return x1
+    
+class PINNhd_ma(nn.Module):
+    """ $h,d \mapsto m_a $
+
+    
+    """
+    def __init__(self):
+        super(PINNhd_ma,self).__init__()
+        weights = tensor([0.01])
+        self.weights = nn.Parameter(weights)
+    def forward(self,x):
+        c, = self.weights
+        x1 = c*x[0]*x[1]
+        return x1
+    
+class PINNT_ma(nn.Module):
+    """$ m_a, U \mapsto T$
+
+   
+    """
+    def __init__(self):
+        super(PINNT_ma,self).__init__()
+        weights = tensor([0.01])
+        self.weights = nn.Parameter(weights)
+    def forward(self,x):
+        c, = self.weights
+        x1 = c*x[0]*x[1]**0.5
+        return x1
+    
+    
+    
+    
+    
+
+    
+    

README.md

@@ -0,0 +1,13 @@
+---
+title: Hetfit
+emoji: 📉
+colorFrom: yellow
+colorTo: blue
+sdk: streamlit
+sdk_version: 1.17.0
+app_file: app.py
+pinned: false
+license: cc-by-nc-4.0
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,83 @@
+import streamlit as st
+
+from nets.envs import SCI
+
+
+st.set_page_config(
+        page_title="HET_sci",
+        menu_items={
+            'About':'https://advpropsys.github.io'
+        }
+)
+
+st.title('HETfit_scientific')
+st.markdown("#### Imagine a package which was engineered primarly for data driven plasma physics devices design, mainly low power hall effect thrusters, yup that's it"
+            "\n### :orange[Don't be scared away though, it has much simpler interface than anything you ever used for such designs]")
+st.markdown('### Main concepts:')
+st.markdown( "- Each observational/design session is called an **environment**, for now it can be either RCI or SCI (Real or scaled interface)"
+            "\n In this overview we will only touch SCI, since RCI is using PINNs which are different topic"
+            "\n- You specify most of the run parameters on this object init, :orange[**including generation of new samples**] via GAN"
+            "\n- You may want to generate new features, do it !"
+            "\n- Want to select best features for more effctive work? Done!"
+            "\n- Compile environment with your model of choice, can be ***any*** torch model or sklearn one"
+            "\n- Train !"
+            "\n- Plot, inference, save, export to jit/onnx, measure performance - **they all are one liners** "
+            )
+st.markdown('### tl;dr \n- Create environment'
+            '\n```run = SCI(*args,**kwargs)```'
+            '\n - Generate features ```run.feature_gen()``` '
+            '\n - Select features ```run.feature_importance()```'
+            '\n - Compile env ```run.compile()```'
+            '\n - Train model in env ```run.train()```'
+            '\n - Inference, plot, performance, ex. ```run.plot3d()```'
+            '\n #### And yes, it all will work even without any additional arguments from user besides column indexes'
+            )
+st.write('Comparison with *arXiv:2206.04440v3*')
+col1, col2 = st.columns(2)
+col1.metric('Geometry accuracy on domain',value='83%',delta='15%')
+col2.metric('$d \mapsto h$ prediction',value='98%',delta='14%')
+
+st.header('Example:')
+
+st.markdown('Remeber indexes and column names on this example: $P$ - 1, $d$ - 3, $h$ - 3, $m_a$ - 6,$T$ - 7')
+st.code('run = SCI(*args,**kwargs)')
+
+run = SCI()
+st.code('run.feature_gen()')
+run.feature_gen()
+st.write('New features: (index-0:22 original samples, else is GAN generated)',run.df.iloc[1:,9:].astype(float))
+st.write('Most of real dataset is from *doi:0.2514/1.B37424*, hence the results mostly agree with it in specific')
+st.code('run.feature_importance(run.df.iloc[1:,1:7].astype(float),run.df.iloc[1:,7]) # Clear and easy example')
+
+st.write(run.feature_importance(run.df.iloc[1:,1:6].astype(float),run.df.iloc[1:,6]))
+st.markdown(' As we can see only $h$ and $d$ passed for $m_a$ model, not only that linear dependacy was proven experimantally, but now we got this from data driven source')
+st.code('run.compile(idx=(1,3,7))')
+run.compile(idx=(1,3,7))
+st.code('run.train(epochs=10)')
+if st.button('Start Training⏳',use_container_width=True):
+    run.train(epochs=10)
+    st.code('run.plot3d()')
+    st.write(run.plot3d())
+    st.code('run.performance()')
+    st.write(run.performance())
+else:
+    st.markdown('#')
+    
+st.markdown('---\nTry it out yourself! Select a column from 1 to 10')
+
+
+number = st.number_input('Here',min_value=1, max_value=10, step=1)
+
+if number:
+    if st.button('Compile And Train💅',use_container_width=True):
+        st.code(f'run.compile(idx=(1,3,{number}))')
+        run.compile(idx=(1,3,number))
+        st.code('run.train(epochs=10)')
+        run.train(epochs=10)
+        st.code('run.plot3d()')
+        st.write(run.plot3d())
+
+
+
+st.markdown('In this intro we covered simplest userflow while using HETFit package, resulted data can be used to leverage PINN and analytical models of Hall effect thrusters'
+            '\n #### :orange[To cite please contact author on https://github.com/advpropsys]')

bb.md

@@ -0,0 +1,38 @@
+<a id="nets.opti.blackbox"></a>
+
+# :orange[Hyper Paramaters Optimization class]
+## nets.opti.blackbox
+
+<a id="nets.opti.blackbox.Hyper"></a>
+
+### Hyper Objects
+
+```python
+class Hyper(SCI)
+```
+
+Hyper parameter tunning class. Allows to generate best NN architecture for task. Inputs are column indexes. idx[-1] is targeted value.
+
+<a id="nets.opti.blackbox.Hyper.start_study"></a>
+
+#### start\_study
+
+```python
+def start_study(n_trials: int = 100,
+                neptune_project: str = None,
+                neptune_api: str = None)
+```
+
+Starts study. Optionally provide your neptune repo and token for report generation.
+
+**Arguments**:
+
+- `n_trials` _int, optional_ - Number of iterations. Defaults to 100.
+- `neptune_project` _str, optional_ - None
+- neptune_api (str, optional):. Defaults to None.
+  
+
+**Returns**:
+
+- `dict` - quick report of results
+

data/dataset.csv

@@ -0,0 +1,24 @@
+Name,U,d,h,j,Isp,nu_t,T,m_a
+SPT-20 [21],52.4,180,15.0,5.0,32.0,0.47,3.9,839
+SPT-25 [22],134,180,20.0,5.0,10,0.59,5.5,948
+HET-100 [23],174,300,23.5,5.5,14.5,0.50,6.8,1386
+KHT-40 [24],187,325,31.0,9.0,25.5,0.69,10.3,1519
+KHT-50 [24],193,250,42.0,8.0,25.0,0.88,11.6,1339
+HEPS-200,195,250,42.5,8.5,25.0,0.88,11.2,1300
+BHT-200 [2526],200,250,21.0,5.6,11.2,0.94,12.8,1390
+KM-32 [27],215,250,32.0,7.0,16.0,1.00,12.2,1244
+SPT-50M [28],245,200,39.0,11.0,25.0,1.50,16.0,1088
+SPT-30 [23],258,250,24.0,6.0,11.0,0.98,13.2,1234
+KM-37 [29],283,292,37.0,9.0,17.5,1.15,18.5,1640
+CAM200 [3031],304,275,43.0,12.0,24,1.09,17.3,1587
+SPT-50 [21],317,300,39.0,11.0,25.0,1.18,17.5,1746
+A-3 [21],324,300,47.0,13.0,30.0,1.18,18.0,1821
+HEPS-500,482,300,49.5,15.5,25.0,1.67,25.9,1587
+BHT-600 [2632],615,300,56.0,16.0,32,2.60,39.1,1530
+SPT-70 [33],660,300,56.0,14.0,25.0,2.56,40.0,1593
+SPT-100 [934],1350,300,85.0,15.0,25.0,5.14,81.6,1540
+UAH-78AM,520,260,78.0,20,40,2,30,1450
+MaSMi40,330,300,40,6.28,12.56,1.5,13,1100
+MaSMi60,700,250,60,9.42,19,2.56,30,1300
+MaSMiDm,1000,500,67,10.5,21,3,53,1940
+Music-si,140,288,18,2,6.5,0.44,4.2,850

docs/main.html

@@ -0,0 +1,106 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv="content-type" content="text/html;charset=utf-8">
+  <title>main.py</title>
+  <link rel="stylesheet" href="pycco.css">
+</head>
+<body>
+<div id='container'>
+  <div id="background"></div>
+  <div class='section'>
+    <div class='docs'><h1>main.py</h1></div>
+  </div>
+  <div class='clearall'>
+  <div class='section' id='section-0'>
+    <div class='docs'>
+      <div class='octowrap'>
+        <a class='octothorpe' href='#section-0'>#</a>
+      </div>
+      
+    </div>
+    <div class='code'>
+      <div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">streamlit</span> <span class="k">as</span> <span class="nn">st</span>
+
+<span class="kn">from</span> <span class="nn">nets.envs</span> <span class="kn">import</span> <span class="n">SCI</span>
+
+
+<span class="n">st</span><span class="o">.</span><span class="n">set_page_config</span><span class="p">(</span>
+        <span class="n">page_title</span><span class="o">=</span><span class="s2">&quot;HET_sci&quot;</span><span class="p">,</span>
+        <span class="n">menu_items</span><span class="o">=</span><span class="p">{</span>
+            <span class="s1">&#39;About&#39;</span><span class="p">:</span><span class="s1">&#39;https://advpropsys.github.io&#39;</span>
+        <span class="p">}</span>
+<span class="p">)</span>
+
+<span class="n">st</span><span class="o">.</span><span class="n">title</span><span class="p">(</span><span class="s1">&#39;HETfit_scientific&#39;</span><span class="p">)</span>
+<span class="n">st</span><span class="o">.</span><span class="n">markdown</span><span class="p">(</span><span class="s2">&quot;#### Imagine a package which was engineered primarly for data driven plasma physics devices design, mainly hall effect thrusters, yup that&#39;s it&quot;</span>
+            <span class="s2">&quot;</span><span class="se">\n</span><span class="s2">### :orange[Don&#39;t be scared away though, it has much simpler interface than anything you ever used for such designs]&quot;</span><span class="p">)</span>
+<span class="n">st</span><span class="o">.</span><span class="n">markdown</span><span class="p">(</span><span class="s1">&#39;### Main concepts:&#39;</span><span class="p">)</span>
+<span class="n">st</span><span class="o">.</span><span class="n">markdown</span><span class="p">(</span> <span class="s2">&quot;- Each observational/design session is called an **environment**, for now it can be either RCI or SCI (Real or scaled interface)&quot;</span>
+            <span class="s2">&quot;</span><span class="se">\n</span><span class="s2"> In this overview we will only touch SCI, since RCI is using PINNs which are different topic&quot;</span>
+            <span class="s2">&quot;</span><span class="se">\n</span><span class="s2">- You specify most of the run parameters on this object init, :orange[**including generation of new samples**] via GAN&quot;</span>
+            <span class="s2">&quot;</span><span class="se">\n</span><span class="s2">- You may want to generate new features, do it !&quot;</span>
+            <span class="s2">&quot;</span><span class="se">\n</span><span class="s2">- Want to select best features for more effctive work? Done!&quot;</span>
+            <span class="s2">&quot;</span><span class="se">\n</span><span class="s2">- Compile environment with your model of choice, can be ***any*** torch model or sklearn one&quot;</span>
+            <span class="s2">&quot;</span><span class="se">\n</span><span class="s2">- Train !&quot;</span>
+            <span class="s2">&quot;</span><span class="se">\n</span><span class="s2">- Plot, inference, save, export to jit/onnx, measure performance - **they all are one liners** &quot;</span>
+            <span class="p">)</span>
+<span class="n">st</span><span class="o">.</span><span class="n">markdown</span><span class="p">(</span><span class="s1">&#39;### tl;dr </span><span class="se">\n</span><span class="s1">- Create environment&#39;</span>
+            <span class="s1">&#39;</span><span class="se">\n</span><span class="s1">```run = SCI(*args,**kwargs)```&#39;</span>
+            <span class="s1">&#39;</span><span class="se">\n</span><span class="s1"> - Generate features ```run.feature_gen()``` &#39;</span>
+            <span class="s1">&#39;</span><span class="se">\n</span><span class="s1"> - Select features ```run.feature_importance()```&#39;</span>
+            <span class="s1">&#39;</span><span class="se">\n</span><span class="s1"> - Compile env ```run.compile()```&#39;</span>
+            <span class="s1">&#39;</span><span class="se">\n</span><span class="s1"> - Train model in env ```run.train()```&#39;</span>
+            <span class="s1">&#39;</span><span class="se">\n</span><span class="s1"> - Inference, plot, performance, ex. ```run.plot3d()```&#39;</span>
+            <span class="s1">&#39;</span><span class="se">\n</span><span class="s1"> #### And yes, it all will work even without any additional arguments from user besides column indexes&#39;</span>
+            <span class="p">)</span>
+<span class="n">st</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="s1">&#39;Comparison with *arXiv:2206.04440v3*&#39;</span><span class="p">)</span>
+<span class="n">col1</span><span class="p">,</span> <span class="n">col2</span> <span class="o">=</span> <span class="n">st</span><span class="o">.</span><span class="n">columns</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
+<span class="n">col1</span><span class="o">.</span><span class="n">metric</span><span class="p">(</span><span class="s1">&#39;Geometry accuracy on domain&#39;</span><span class="p">,</span><span class="n">value</span><span class="o">=</span><span class="s1">&#39;83%&#39;</span><span class="p">,</span><span class="n">delta</span><span class="o">=</span><span class="s1">&#39;15%&#39;</span><span class="p">)</span>
+<span class="n">col2</span><span class="o">.</span><span class="n">metric</span><span class="p">(</span><span class="s1">&#39;$d \mapsto h$ prediction&#39;</span><span class="p">,</span><span class="n">value</span><span class="o">=</span><span class="s1">&#39;98%&#39;</span><span class="p">,</span><span class="n">delta</span><span class="o">=</span><span class="s1">&#39;14%&#39;</span><span class="p">)</span>
+
+<span class="n">st</span><span class="o">.</span><span class="n">header</span><span class="p">(</span><span class="s1">&#39;Example:&#39;</span><span class="p">)</span>
+
+<span class="n">st</span><span class="o">.</span><span class="n">markdown</span><span class="p">(</span><span class="s1">&#39;Remeber indexes and column names on this example: $P$ - 1, $d$ - 3, $h$ - 3, $m_a$ - 6,$T$ - 7&#39;</span><span class="p">)</span>
+<span class="n">st</span><span class="o">.</span><span class="n">code</span><span class="p">(</span><span class="s1">&#39;run = SCI(*args,**kwargs)&#39;</span><span class="p">)</span>
+
+<span class="n">run</span> <span class="o">=</span> <span class="n">SCI</span><span class="p">()</span>
+<span class="n">st</span><span class="o">.</span><span class="n">code</span><span class="p">(</span><span class="s1">&#39;run.feature_gen()&#39;</span><span class="p">)</span>
+<span class="n">run</span><span class="o">.</span><span class="n">feature_gen</span><span class="p">()</span>
+<span class="n">st</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="s1">&#39;New features: (index-0:22 original samples, else is GAN generated)&#39;</span><span class="p">,</span><span class="n">run</span><span class="o">.</span><span class="n">df</span><span class="o">.</span><span class="n">iloc</span><span class="p">[</span><span class="mi">1</span><span class="p">:,</span><span class="mi">9</span><span class="p">:]</span><span class="o">.</span><span class="n">astype</span><span class="p">(</span><span class="nb">float</span><span class="p">))</span>
+<span class="n">st</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="s1">&#39;Most of real dataset is from *doi:0.2514/1.B37424*, hence the results mostly agree with it in specific&#39;</span><span class="p">)</span>
+<span class="n">st</span><span class="o">.</span><span class="n">code</span><span class="p">(</span><span class="s1">&#39;run.feature_importance(run.df.iloc[1:,1:7].astype(float),run.df.iloc[1:,7]) # Clear and easy example&#39;</span><span class="p">)</span>
+
+<span class="n">st</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="n">run</span><span class="o">.</span><span class="n">feature_importance</span><span class="p">(</span><span class="n">run</span><span class="o">.</span><span class="n">df</span><span class="o">.</span><span class="n">iloc</span><span class="p">[</span><span class="mi">1</span><span class="p">:,</span><span class="mi">1</span><span class="p">:</span><span class="mi">6</span><span class="p">]</span><span class="o">.</span><span class="n">astype</span><span class="p">(</span><span class="nb">float</span><span class="p">),</span><span class="n">run</span><span class="o">.</span><span class="n">df</span><span class="o">.</span><span class="n">iloc</span><span class="p">[</span><span class="mi">1</span><span class="p">:,</span><span class="mi">6</span><span class="p">]))</span>
+<span class="n">st</span><span class="o">.</span><span class="n">markdown</span><span class="p">(</span><span class="s1">&#39; As we can see only $h$ and $d$ passed for $m_a$ model, not only that linear dependacy was proven experimantally, but now we got this from data driven source&#39;</span><span class="p">)</span>
+<span class="n">st</span><span class="o">.</span><span class="n">code</span><span class="p">(</span><span class="s1">&#39;run.compile(idx=(1,3,7))&#39;</span><span class="p">)</span>
+<span class="n">run</span><span class="o">.</span><span class="n">compile</span><span class="p">(</span><span class="n">idx</span><span class="o">=</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">7</span><span class="p">))</span>
+<span class="n">st</span><span class="o">.</span><span class="n">code</span><span class="p">(</span><span class="s1">&#39;run.train(epochs=10)&#39;</span><span class="p">)</span>
+<span class="n">run</span><span class="o">.</span><span class="n">train</span><span class="p">(</span><span class="n">epochs</span><span class="o">=</span><span class="mi">10</span><span class="p">)</span>
+<span class="n">st</span><span class="o">.</span><span class="n">code</span><span class="p">(</span><span class="s1">&#39;run.plot3d()&#39;</span><span class="p">)</span>
+<span class="n">st</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="n">run</span><span class="o">.</span><span class="n">plot3d</span><span class="p">())</span>
+<span class="n">st</span><span class="o">.</span><span class="n">code</span><span class="p">(</span><span class="s1">&#39;run.performance()&#39;</span><span class="p">)</span>
+<span class="n">st</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="n">run</span><span class="o">.</span><span class="n">performance</span><span class="p">())</span>
+
+<span class="n">st</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="s1">&#39;Try it out yourself! Select a column from 1 to 10&#39;</span><span class="p">)</span>
+<span class="n">number</span> <span class="o">=</span> <span class="n">st</span><span class="o">.</span><span class="n">number_input</span><span class="p">(</span><span class="s1">&#39;Here&#39;</span><span class="p">,</span><span class="n">min_value</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">max_value</span><span class="o">=</span><span class="mi">10</span><span class="p">,</span> <span class="n">step</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
+
+<span class="k">if</span> <span class="n">number</span><span class="p">:</span>
+    <span class="n">st</span><span class="o">.</span><span class="n">code</span><span class="p">(</span><span class="sa">f</span><span class="s1">&#39;run.compile(idx=(1,3,</span><span class="si">{</span><span class="n">number</span><span class="si">}</span><span class="s1">))&#39;</span><span class="p">)</span>
+    <span class="n">run</span><span class="o">.</span><span class="n">compile</span><span class="p">(</span><span class="n">idx</span><span class="o">=</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="n">number</span><span class="p">))</span>
+    <span class="n">st</span><span class="o">.</span><span class="n">code</span><span class="p">(</span><span class="s1">&#39;run.train(epochs=10)&#39;</span><span class="p">)</span>
+    <span class="n">run</span><span class="o">.</span><span class="n">train</span><span class="p">(</span><span class="n">epochs</span><span class="o">=</span><span class="mi">10</span><span class="p">)</span>
+    <span class="n">st</span><span class="o">.</span><span class="n">code</span><span class="p">(</span><span class="s1">&#39;run.plot3d()&#39;</span><span class="p">)</span>
+    <span class="n">st</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="n">run</span><span class="o">.</span><span class="n">plot3d</span><span class="p">())</span>
+
+
+
+<span class="n">st</span><span class="o">.</span><span class="n">markdown</span><span class="p">(</span><span class="s1">&#39;In this intro we covered simplest user flow while using HETFit package, resulted data can be used to leverage PINN and analytical models of Hall effect thrusters&#39;</span>
+            <span class="s1">&#39;</span><span class="se">\n</span><span class="s1"> #### :orange[To cite please contact author on https://github.com/advpropsys]&#39;</span><span class="p">)</span>
+
+</pre></div>
+    </div>
+  </div>
+  <div class='clearall'></div>
+</div>
+</body>

intro.md

@@ -0,0 +1,453 @@
+# :orange[Abstract:] 
+  Hall effect thrusters are one of the most versatile and
+  popular electric propulsion systems for space use. Industry trends
+  towards interplanetary missions arise advances in design development
+  of such propulsion systems. It is understood that correct sizing of
+  discharge channel in Hall effect thruster impact performance greatly.
+  Since the complete physics model of such propulsion system is not yet
+  optimized for fast computations and design iterations, most thrusters
+  are being designed using so-called scaling laws. But this work focuses
+  on rather novel approach, which is outlined less frequently than
+  ordinary scaling design approach in literature. Using deep machine
+  learning it is possible to create predictive performance model, which
+  can be used to effortlessly get design of required hall thruster with
+  required characteristics using way less computing power than design
+  from scratch and way more flexible than usual scaling approach.
+:orange[author:] Korolev K.V [^1]
+title: Hall effect thruster design via deep neural network for additive
+  manufacturing
+
+# Nomenclature
+
+<div class="longtable*" markdown="1">
+
+$U_d$ = discharge voltage  
+$P$ = discharge power  
+$T$ = thrust  
+$\dot{m}_a$ = mass flow rate  
+$I_{sp}$ = specific impulse  
+$\eta_m$ = mass utilization efficiency  
+$\eta_a$ = anode efficiency  
+$j$ = $P/v$ \[power density\]  
+$v$ = discharge channel volume  
+$h, d, L$ = generic geometry parameters  
+$C_*$ = set of scaling coefficients  
+$g$ = free-fall acceleration  
+$M$ = ion mass
+
+</div>
+
+# Introduction
+
+<span class="lettrine">T</span><span class="smallcaps">he</span>
+application of deep learning is extremely diverse, but in this study it
+focuses on case of hall effect thruster design. Hall effect thruster
+(HET) is rather simple DC plasma acceleration device, due to complex and
+non linear process physics we don’t have any full analytical performance
+models yet. Though there are a lot of ways these systems are designed in
+industry with great efficiencies, but in cost of multi-million research
+budgets and time. This problem might be solved using neural network
+design approach and few hardware iteration tweaks(Plyashkov et al.
+2022-10-25).
+
+Scaled thrusters tend to have good performance but this approach isn’t
+that flexible for numerous reasons: first and foremost, due to large
+deviations in all of the initial experimental values accuracy can be not
+that good, secondly, it is hardly possible to design thruster with
+different power density or $I_{sp}$ efficiently.
+
+On the other hand, the neural network design approach has accuracy
+advantage only on domain of the dataset(Plyashkov et al. 2022-10-25),
+this limitations is easily compensated by ability to create relations
+between multiple discharge and geometry parameters at once. Hence this
+novel approach and scaling relations together could be an ultimate
+endgame design tool for HET.
+
+Note that neither of these models do not include cathode efficiencies
+and performances. So as the neutral gas thrust components. Most
+correlations in previous literature were made using assumption or
+physics laws(Shagayda and Gorshkov 2013-03), in this paper the new
+method based on feature generation, GAN dataset augmentation and ML
+feature selection is suggested.
+
+## Dataset enlargement using GAN
+
+As we already have discussed, the data which is available is not enough
+for training NN or most ML algorithms, so I suggest using Generative
+Adversarial Network to generate more similar points. Generative model
+trains two different models - generator and discriminator. Generator
+learns how to generate new points which are classified by discriminator
+as similar to real dataset. Of course it is very understandable that
+model needs to be precise enough not to overfit on data or create new
+unknown correlations. Model was checked via Mean Absolute Percentage
+Error (MAPE) and physical boundary conditions. After assembling most
+promising architecture, the model was able to generate fake points with
+MAPE of $~4.7\%$. We need to measure MAPE to be sure point lie on same
+domain as original dataset, as in this work we are interested in
+sub-kilowatt thrusters. After model generated new points they were check
+to fit in physical boundaries of scaled values (for example thrust
+couldn’t be more than 2, efficiency more than 1.4 and so on, data was
+scaled on original dataset to retain quality), only 0.02% of points were
+found to be outliers. The GAN architecture and dataset sample is
+provided as follows.
+
+<!-- ![GAN architecture](gen.png "GAN architecture")
+![Sample of generated datagray - fake, blue - real](dT.png "Sample of generated datagray - fake, blue - real") -->
+
+# General Relations
+
+As we will use dataset of only low power hall thrusters, we can just
+ignore derivation of any non-linear equations and relations and use
+traditional approach here. Let’s define some parameters of anode:
+$$\alpha = \frac{\dot{m}\beta}{{\dot{m}_a}},$$
+Where $\alpha$ is anode
+parameter of $\beta$ thruster parameter. This is selected because this
+way cathode and other losses wont be included in the model. One of key
+differences in this approach is fitting only best and most appropriate
+data, thus we will eliminate some variance in scaling laws. Though due
+to machine learning methods, we would need a lot of information which is
+simply not available in those volumes. So some simplifications and
+assumptions could be made. Firstly, as it was already said, we don’t
+include neutralizer efficiency in the model. Secondly, the model would
+be correct on very specific domain, defined by dataset, many parameters
+like anode power and $I_{sp}$ still are using semi-empirical modelling
+approach. The results we are looking for are outputs of machine learning
+algorithm: specific impulse, thrust, efficiency, optimal mass flow rate,
+power density. Function of input is solely dependant on power and
+voltage range. For the matter of topic let’s introduce semi-empirical
+equations which are used for scaling current thrusters.
+
+<div class="longtable*" markdown="2">
+
+$$h=C_hd$$
+
+$$\dot{m_a} = C_m hd$$
+
+$$P_d=C_pU_dd^2$$
+
+$$T=C_t\dot{m_a}\sqrt{U_d}$$
+
+$$I_{spa}=\frac{T}{\dot{m_a} g}$$
+
+$$\eta_a=\frac{T}{2\dot{m_a}P_d}$$
+
+</div>
+
+Where $C_x$ is scaling coefficient obtained from analytical modelling,
+which makes equations linear. Generally it has 95% prediction band but
+as was said earlier this linearity is what gives problems to current
+thrusters designs (high mass, same power density, average performance).
+The original dataset is
+
+|          |          |        |       |       |       |              |      |           |
+|:---------|:---------|:-------|:------|:------|:------|:-------------|:-----|:----------|
+| Thruster | Power, W | U_d, V | d, mm | h, mm | L, mm | m_a,.g/s,    | T, N | I\_spa, s |
+| SPT-20   | 52.4     | 180    | 15.0  | 5.0   | 32.0  | 0.47         | 3.9  | 839       |
+| SPT-25   | 134      | 180    | 20.0  | 5.0   | 10    | 0.59         | 5.5  | 948       |
+| Music-si | 140      | 288    | 18    | 2     | 6.5   | 0.44         | 4.2  | 850       |
+| HET-100  | 174      | 300    | 23.5  | 5.5   | 14.5  | 0.50         | 6.8  | 1386      |
+| KHT-40   | 187      | 325    | 31.0  | 9.0   | 25.5  | 0.69         | 10.3 | 1519      |
+| KHT-50   | 193      | 250    | 42.0  | 8.0   | 25.0  | 0.88         | 11.6 | 1339      |
+| HEPS-200 | 195      | 250    | 42.5  | 8.5   | 25.0  | 0.88         | 11.2 | 1300      |
+| BHT-200  | 200      | 250    | 21.0  | 5.6   | 11.2  | 0.94         | 12.8 | 1390      |
+| KM-32    | 215      | 250    | 32.0  | 7.0   | 16.0  | 1.00         | 12.2 | 1244      |
+| ...      |          |        |       |       |       |              |      |           |
+| HEPS-500 | 482      | 300    | 49.5  | 15.5  | 25.0  | 1.67         | 25.9 | 1587      |
+| UAH-78AM | 520      | 260    | 78.0  | 20    | 40    | 2            | 30   | 1450      |
+| BHT-600  | 615      | 300    | 56.0  | 16.0  | 32    | 2.60         | 39.1 | 1530      |
+| SPT-70   | 660      | 300    | 56.0  | 14.0  | 25.0  | 2.56         | 40.0 | 1593      |
+| MaSMi60  | 700      | 250    | 60    | 9.42  | 19    | 2.56         | 30   | 1300      |
+| MaSMiDm  | 1000     | 500    | 67    | 10.5  | 21    | 3            | 53   | 1940      |
+| SPT-100  | 1350     | 300    | 85.0  | 15.0  | 25.0  | 5.14         | 81.6 | 1540      |
+
+Hosting only 24 entries in total. The references are as follows(Beal et
+al. 2004-11)(Belikov et al. 2001-07-08)(Kronhaus et al. 2013-07)(Misuri
+and Andrenucci 2008-07-21)(Lee et al. 2019-11)
+
+In the next section the used neural networks architectures will be
+discussed.
+
+# Data driven HET designs
+
+Neural networks are a type of machine learning algorithm that is often
+used in the field of artificial intelligence. They are mathematical
+models that can be trained to recognize patterns within large datasets.
+The architecture of GAN’s generator was already shown. In this section
+we will focus on fully connected networks, which are most popular for
+type for these tasks. HETFit code leverages dynamic architecture
+generation of these FcNN’s which is done via meta learning algorithm
+Tree-structured Parzen Estimator for every data input user selects. This
+code uses state-of-art implementation made by OPTUNA. The dynamically
+suggested architecture has 2 to 6 layers from 4 to 128 nodes on each
+with SELU, Tanh or ReLU activations and most optimal optimizer. The code
+user interface is as follows: 1. Specify working environment 2. Load or
+generate data 3. Tune the architecture 4. Train and get robust scaling
+models
+
+## FNN
+
+All of Fully connected neural networks are implemented in PyTorch as it
+the most powerful ML/AI library for experiments. When the network
+architecture is generated, all of networks have similar training loops
+as they use gradient descend algorithm : Loss function:
+$$L(w, b) \equiv \frac{1}{2 n} \sum_x\|y(x)-a\|^2$$ This one is mean
+square error (MSE) error function most commonly used in FNNs. Next we
+iterate while updating weights for a number of specified epochs this
+way. Loop for number of epochs:
+
+\- Get predictions: $\hat{y}$
+
+\- Compute loss: $\mathscr{L}(w, b)$
+
+\- Make backward pass
+
+\- Update optimizer
+
+It can be mentioned that dataset of electric propulsion is extremely
+complex due to large deviations in data. Thanks to adavnces in data
+science and ML it is possible to work with it.
+
+This way we assembled dataset on our ROI domain of $P$\<1000 $W$ input
+power and 200-500 $V$ range. Sadly one of limitations of such model is
+disability to go beyond actual database limit while not sacrificing
+performance and accuracy.
+
+## Physics Informed Neural Networks
+
+For working with unscaled data PINN’s were introduced, they are using
+equations 2-7 to generate $C_x$ coefficients. Yes, it was said earlier
+that this method lacks ability to generate better performing HETs, but
+as we have generated larger dataset on same domain as Lee et al.
+(2019-11) it is important to control that our dataset is still the same
+quality as original. Using above mentioned PINN’s it was possible to fit
+coefficients and they showed only slight divergence in values of few %
+which is acceptable.
+
+## ML approach notes
+
+We already have discussed how HETFit code works and results it can
+generate, the overiew is going to be given in next section. But here i
+want to warn that this work is highly experimental and you should always
+take ML approaches with a grain of salt, as some plasma discharge
+physics in HET is yet to be understood, data driven way may have some
+errors in predictions on specific bands. Few notes on design tool I have
+developed in this work: it is meant to be used by people with little to
+no experience in ML field but those who wants to quickly analyze their
+designs or create baseline one for simulations. One can even use this
+tool for general tabular data as it has mostly no limits whatsoever to
+input data.
+
+## Two input variables prediction
+
+One of main characteristics for any type of thruster is efficiency, in
+this work I researched dependency of multiple input values to $\eta_t$.
+Results are as follows in form of predicted matrix visualisations.
+Figure 3 takes into account all previous ones in the same time, once
+again it would be way harder to do without ML.
+
+
+
+# Results discussion
+
+Let’s compare predictions of semi empirical approach(Lee et al.
+2019-11), approach in paper(Plyashkov et al. 2022-10-25), and finally
+ours. Worth to mention that current approach is easiest to redesign from
+scratch.
+
+## NN architecture generation algorithm
+
+As with 50 iterations, previously discussed meta learning model is able
+to create architecture with score of 0.9+ in matter of seconds. HETFit
+allows logging into neptune.ai environment for full control over
+simulations. Example trail run looks like that.
+
+
+
+## Power density and magnetic flux dependence
+
+Neither of the models currently support taking magnetic flux in account
+besides general physics relations, but we are planning on updating the
+model in next follow up paper. For now $\vec{B}$ relation to power
+remains unresolved to ML approach but the magnetic field distribution on
+z axis is computable and looks like that for magnetically shielded
+thrusters:
+
+
+
+## Dependency of T on d,P
+
+Following graph is describing Thrust as function of channel diameter and
+width, where hue map is thrust. It is well known dependency and it has
+few around 95% prediction band (Lee et al. 2019-11)
+
+
+
+## Dependency of T on P,U
+
+
+
+## Dependency of T on $m_a$,P
+
+Compared to(Shagayda and Gorshkov 2013-03) The model accounts for more
+parameters than linear relation. So such method proves to be more
+precise on specified domain than semi empirical linear relations.
+
+
+
+## Dependency of $I_{sp}$ on d,h
+
+
+
+We generated many models so far, but using ML we can make single model
+for all of the parameters at the same time, so these graphs tend to be
+3d projection of such model inference.
+
+## Use of pretrained model in additive manufacturing of hall effect thruster channels
+
+The above mentioned model was used to predict geometry of channel, next
+the simulation was conducted on this channel. Second one for comparison
+was calculated via usual scaling laws. The initial conditions for both
+are:
+
+| Initial condition | Value             |
+|:------------------|:------------------|
+| $n_{e,0}$         | 1e13 \[m\^-3\]    |
+| $\epsilon_0$      | 4 \[V\]           |
+| V                 | 300 \[V\]         |
+| T                 | 293.15 \[K\]      |
+| P\_abs            | 0.5 \[torr\]      |
+| $\mu_e N_n$       | 1e25 \[1/(Vm s)\] |
+| dt                | 1e-8 \[s\]        |
+| Body              | Ar                |
+
+Outcomes are so that ML geometry results in higher density generation of
+ions which leads to more efficient thrust generation. HETFit code
+suggests HET parameters by lower estimate to compensate for not included
+variables in model of HET. This is experimentally proven to be efficient
+estimate since SEM predictions of thrust are always higher than real
+performance. Lee et al. (2019-11)
+
+
+
+## Code description
+
+Main concepts: - Each observational/design session is called an
+environment, for now it can be either RCI or SCI (Real or scaled
+interface)
+
+\- Most of the run parameters are specified on this object
+initialization, including generation of new samples via GAN
+
+\- Built-in feature generation (log10 Power, efficiency, $\vec{B}$,
+etc.)
+
+\- Top feature selection for each case. (Boruta algorithm)
+
+\- Compilation of environment with model of choice, can be any torch
+model or sklearn one
+
+\- Training
+
+\- Plot, inference, save, export to jit/onnx, measure performance
+
+## COMSOL HET simulations
+
+The simulations were conducted in COMSOL in plasma physics interface
+which gives the ability to accurately compute Electron densities,
+temperatures, energy distribution functions from initial conditions and
+geometry. Here is comparison of both channels.
+
+
+
+# Conclusion
+
+In conclusion the another model of scaling laws was made and presented.
+HETFit code is open source and free to be used by anyone. Additively
+manufactured channel was printed to prove it’s manufactureability.
+Hopefully this work will help developing more modern scaling relations
+as current ones are far from perfect.
+
+Method in this paper and firstly used in Plyashkov et al. (2022-10-25)
+has advantages over SEM one in: ability to preidct performance more
+precisely on given domain, account for experimental data. I believe with
+more input data the ML method of deisgning thrusters would be more
+widely used.
+
+The code in this work could be used with other tabular experimental data
+since most of cases and tasks tend to be the same: feature selection and
+model optimization.
+
+
+<div id="refs" class="references csl-bib-body hanging-indent"
+markdown="1">
+
+<div id="ref-beal_plasma_2004" class="csl-entry" markdown="1">
+
+Beal, Brian E., Alec D. Gallimore, James M. Haas, and William A. Hargus.
+2004-11. “Plasma Properties in the Plume of a Hall Thruster Cluster.”
+*Journal of Propulsion and Power* 20 (6): 985–91.
+<https://doi.org/10.2514/1.3765>.
+
+</div>
+
+<div id="ref-belikov_high-performance_2001" class="csl-entry"
+markdown="1">
+
+Belikov, M., O. Gorshkov, V. Muravlev, R. Rizakhanov, A. Shagayda, and
+A. Snnirev. 2001-07-08. “High-Performance Low Power Hall Thruster.” In
+*37th Joint Propulsion Conference and Exhibit*. Salt Lake
+City,UT,U.S.A.: American Institute of Aeronautics; Astronautics.
+<https://doi.org/10.2514/6.2001-3780>.
+
+</div>
+
+<div id="ref-kronhaus_discharge_2013" class="csl-entry" markdown="1">
+
+Kronhaus, Igal, Alexander Kapulkin, Vladimir Balabanov, Maksim
+Rubanovich, Moshe Guelman, and Benveniste Natan. 2013-07. “Discharge
+Characterization of the Coaxial Magnetoisolated Longitudinal Anode Hall
+Thruster.” *Journal of Propulsion and Power* 29 (4): 938–49.
+<https://doi.org/10.2514/1.B34754>.
+
+</div>
+
+<div id="ref-lee_scaling_2019" class="csl-entry" markdown="1">
+
+Lee, Eunkwang, Younho Kim, Hodong Lee, Holak Kim, Guentae Doh, Dongho
+Lee, and Wonho Choe. 2019-11. “Scaling Approach for Sub-Kilowatt
+Hall-Effect Thrusters.” *Journal of Propulsion and Power* 35 (6):
+1073–79. <https://doi.org/10.2514/1.B37424>.
+
+</div>
+
+<div id="ref-misuri_het_2008" class="csl-entry" markdown="1">
+
+Misuri, Tommaso, and Mariano Andrenucci. 2008-07-21. “HET Scaling
+Methodology: Improvement and Assessment.” In *44th AIAA/ASME/SAE/ASEE
+Joint Propulsion Conference &Amp; Exhibit*. Hartford, CT: American
+Institute of Aeronautics; Astronautics.
+<https://doi.org/10.2514/6.2008-4806>.
+
+</div>
+
+<div id="ref-plyashkov_scaling_2022" class="csl-entry" markdown="1">
+
+Plyashkov, Yegor V., Andrey A. Shagayda, Dmitrii A. Kravchenko, Fedor D.
+Ratnikov, and Alexander S. Lovtsov. 2022-10-25. “On Scaling of
+Hall-Effect Thrusters Using Neural Nets,” 2022-10-25.
+<http://arxiv.org/abs/2206.04440>.
+
+</div>
+
+<div id="ref-shagayda_hall-thruster_2013" class="csl-entry"
+markdown="1">
+
+Shagayda, Andrey A., and Oleg A. Gorshkov. 2013-03. “Hall-Thruster
+Scaling Laws.” *Journal of Propulsion and Power* 29 (2): 466–74.
+<https://doi.org/10.2514/1.B34650>.
+
+</div>
+
+</div>
+
+[^1]: Founder, Pure EP

main.md

@@ -0,0 +1,1060 @@
+# Table of Contents
+
+- [Table of Contents](#table-of-contents)
+- [main](#main)
+- [PINN](#pinn)
+- [PINN.pinns](#pinnpinns)
+  - [PINNd\_p Objects](#pinnd_p-objects)
+      - [forward](#forward)
+  - [PINNhd\_ma Objects](#pinnhd_ma-objects)
+  - [PINNT\_ma Objects](#pinnt_ma-objects)
+- [utils](#utils)
+- [utils.test](#utilstest)
+- [utils.dataset\_loader](#utilsdataset_loader)
+      - [get\_dataset](#get_dataset)
+- [utils.ndgan](#utilsndgan)
+  - [DCGAN Objects](#dcgan-objects)
+      - [\_\_init\_\_](#__init__)
+      - [define\_discriminator](#define_discriminator)
+      - [define\_generator](#define_generator)
+      - [build\_models](#build_models)
+      - [generate\_latent\_points](#generate_latent_points)
+      - [generate\_fake\_samples](#generate_fake_samples)
+      - [define\_gan](#define_gan)
+      - [summarize\_performance](#summarize_performance)
+      - [train\_gan](#train_gan)
+      - [start\_training](#start_training)
+      - [predict](#predict)
+- [utils.data\_augmentation](#utilsdata_augmentation)
+  - [dataset Objects](#dataset-objects)
+      - [\_\_init\_\_](#__init__-1)
+      - [generate](#generate)
+- [:orange\[nets\]](#orangenets)
+- [nets.envs](#netsenvs)
+  - [SCI Objects](#sci-objects)
+      - [\_\_init\_\_](#__init__-2)
+      - [feature\_gen](#feature_gen)
+      - [feature\_importance](#feature_importance)
+      - [data\_flow](#data_flow)
+      - [init\_seed](#init_seed)
+      - [train\_epoch](#train_epoch)
+      - [compile](#compile)
+      - [train](#train)
+      - [save](#save)
+      - [onnx\_export](#onnx_export)
+      - [jit\_export](#jit_export)
+      - [inference](#inference)
+      - [plot](#plot)
+      - [plot3d](#plot3d)
+      - [performance](#performance)
+      - [performance\_super](#performance_super)
+  - [RCI Objects](#rci-objects)
+      - [data\_flow](#data_flow-1)
+      - [compile](#compile-1)
+      - [plot](#plot-1)
+      - [performance](#performance-1)
+- [nets.dense](#netsdense)
+  - [Net Objects](#net-objects)
+      - [\_\_init\_\_](#__init__-3)
+- [nets.design](#netsdesign)
+      - [B\_field\_norm](#b_field_norm)
+      - [PUdesign](#pudesign)
+- [nets.deep\_dense](#netsdeep_dense)
+  - [dmodel Objects](#dmodel-objects)
+      - [\_\_init\_\_](#__init__-4)
+- [nets.opti](#netsopti)
+- [nets.opti.blackbox](#netsoptiblackbox)
+  - [Hyper Objects](#hyper-objects)
+      - [\_\_init\_\_](#__init__-5)
+      - [define\_model](#define_model)
+      - [objective](#objective)
+      - [start\_study](#start_study)
+
+<a id="main"></a>
+
+# main
+
+<a id="PINN"></a>
+
+# PINN
+
+<a id="PINN.pinns"></a>
+
+# PINN.pinns
+
+<a id="PINN.pinns.PINNd_p"></a>
+
+## PINNd\_p Objects
+
+```python
+class PINNd_p(nn.Module)
+```
+
+$d \mapsto P$
+
+<a id="PINN.pinns.PINNd_p.forward"></a>
+
+#### forward
+
+```python
+def forward(x)
+```
+
+$P,U$ input, $d$ output
+
+**Arguments**:
+
+- `x` __type__ - _description_
+  
+
+**Returns**:
+
+- `_type_` - _description_
+
+<a id="PINN.pinns.PINNhd_ma"></a>
+
+## PINNhd\_ma Objects
+
+```python
+class PINNhd_ma(nn.Module)
+```
+
+$h,d \mapsto m_a $
+
+<a id="PINN.pinns.PINNT_ma"></a>
+
+## PINNT\_ma Objects
+
+```python
+class PINNT_ma(nn.Module)
+```
+
+$ m_a, U \mapsto T$
+
+<a id="utils"></a>
+
+# utils
+
+<a id="utils.test"></a>
+
+# utils.test
+
+<a id="utils.dataset_loader"></a>
+
+# utils.dataset\_loader
+
+<a id="utils.dataset_loader.get_dataset"></a>
+
+#### get\_dataset
+
+```python
+def get_dataset(raw: bool = False,
+                sample_size: int = 1000,
+                name: str = 'dataset.pkl',
+                source: str = 'dataset.csv',
+                boundary_conditions: list = None) -> _pickle
+```
+
+Gets augmented dataset
+
+**Arguments**:
+
+- `raw` _bool, optional_ - either to use source data or augmented. Defaults to False.
+- `sample_size` _int, optional_ - sample size. Defaults to 1000.
+- `name` _str, optional_ - name of wanted dataset. Defaults to 'dataset.pkl'.
+- `boundary_conditions` _list,optional_ - y1,y2,x1,x2.
+
+**Returns**:
+
+- `_pickle` - pickle buffer
+
+<a id="utils.ndgan"></a>
+
+# utils.ndgan
+
+<a id="utils.ndgan.DCGAN"></a>
+
+## DCGAN Objects
+
+```python
+class DCGAN()
+```
+
+<a id="utils.ndgan.DCGAN.__init__"></a>
+
+#### \_\_init\_\_
+
+```python
+def __init__(latent, data)
+```
+
+The function takes in two arguments, the latent space dimension and the dataframe. It then sets
+
+the latent space dimension, the dataframe, the number of inputs and outputs, and then builds the
+models
+
+**Arguments**:
+
+- `latent`: The number of dimensions in the latent space
+- `data`: This is the dataframe that contains the data that we want to generate
+
+<a id="utils.ndgan.DCGAN.define_discriminator"></a>
+
+#### define\_discriminator
+
+```python
+def define_discriminator(inputs=8)
+```
+
+The discriminator is a neural network that takes in a vector of length 8 and outputs a single
+
+value between 0 and 1
+
+**Arguments**:
+
+- `inputs`: number of features in the dataset, defaults to 8 (optional)
+
+**Returns**:
+
+The model is being returned.
+
+<a id="utils.ndgan.DCGAN.define_generator"></a>
+
+#### define\_generator
+
+```python
+def define_generator(latent_dim, outputs=8)
+```
+
+The function takes in a latent dimension and outputs and returns a model with two hidden layers
+
+and an output layer
+
+**Arguments**:
+
+- `latent_dim`: The dimension of the latent space, or the space that the generator will map
+to
+- `outputs`: the number of outputs of the generator, defaults to 8 (optional)
+
+**Returns**:
+
+The model is being returned.
+
+<a id="utils.ndgan.DCGAN.build_models"></a>
+
+#### build\_models
+
+```python
+def build_models()
+```
+
+The function returns the generator and discriminator models
+
+**Returns**:
+
+The generator and discriminator models are being returned.
+
+<a id="utils.ndgan.DCGAN.generate_latent_points"></a>
+
+#### generate\_latent\_points
+
+```python
+def generate_latent_points(latent_dim, n)
+```
+
+> Generate random points in latent space as input for the generator
+
+**Arguments**:
+
+- `latent_dim`: the dimension of the latent space, which is the input to the generator
+- `n`: number of images to generate
+
+**Returns**:
+
+A numpy array of random numbers.
+
+<a id="utils.ndgan.DCGAN.generate_fake_samples"></a>
+
+#### generate\_fake\_samples
+
+```python
+def generate_fake_samples(generator, latent_dim, n)
+```
+
+It generates a batch of fake samples with class labels
+
+**Arguments**:
+
+- `generator`: The generator model that we will train
+- `latent_dim`: The dimension of the latent space, e.g. 100
+- `n`: The number of samples to generate
+
+**Returns**:
+
+x is the generated images and y is the labels for the generated images.
+
+<a id="utils.ndgan.DCGAN.define_gan"></a>
+
+#### define\_gan
+
+```python
+def define_gan(generator, discriminator)
+```
+
+The function takes in a generator and a discriminator, sets the discriminator to be untrainable,
+
+and then adds the generator and discriminator to a sequential model. The sequential model is then compiled with an optimizer and a loss function. 
+
+The optimizer is adam, which is a type of gradient descent algorithm. 
+
+Loss function is binary crossentropy, which is a loss function that is used for binary
+classification problems. 
+
+
+The function then returns the GAN.
+
+**Arguments**:
+
+- `generator`: The generator model
+- `discriminator`: The discriminator model that takes in a dataset and outputs a single value
+representing fake/real
+
+**Returns**:
+
+The model is being returned.
+
+<a id="utils.ndgan.DCGAN.summarize_performance"></a>
+
+#### summarize\_performance
+
+```python
+def summarize_performance(epoch, generator, discriminator, latent_dim, n=200)
+```
+
+> This function evaluates the discriminator on real and fake data, and plots the real and fake
+
+data
+
+**Arguments**:
+
+- `epoch`: the number of epochs to train for
+- `generator`: the generator model
+- `discriminator`: the discriminator model
+- `latent_dim`: The dimension of the latent space
+- `n`: number of samples to generate, defaults to 200 (optional)
+
+<a id="utils.ndgan.DCGAN.train_gan"></a>
+
+#### train\_gan
+
+```python
+def train_gan(g_model,
+              d_model,
+              gan_model,
+              latent_dim,
+              num_epochs=2500,
+              num_eval=2500,
+              batch_size=2)
+```
+
+**Arguments**:
+
+- `g_model`: the generator model
+- `d_model`: The discriminator model
+- `gan_model`: The GAN model, which is the generator model combined with the discriminator
+model
+- `latent_dim`: The dimension of the latent space. This is the number of random numbers that
+the generator model will take as input
+- `num_epochs`: The number of epochs to train for, defaults to 2500 (optional)
+- `num_eval`: number of epochs to run before evaluating the model, defaults to 2500
+(optional)
+- `batch_size`: The number of samples to use for each gradient update, defaults to 2
+(optional)
+
+<a id="utils.ndgan.DCGAN.start_training"></a>
+
+#### start\_training
+
+```python
+def start_training()
+```
+
+The function takes the generator, discriminator, and gan models, and the latent vector as
+arguments, and then calls the train_gan function.
+
+<a id="utils.ndgan.DCGAN.predict"></a>
+
+#### predict
+
+```python
+def predict(n)
+```
+
+It takes the generator model and the latent space as input and returns a batch of fake samples
+
+**Arguments**:
+
+- `n`: the number of samples to generate
+
+**Returns**:
+
+the generated fake samples.
+
+<a id="utils.data_augmentation"></a>
+
+# utils.data\_augmentation
+
+<a id="utils.data_augmentation.dataset"></a>
+
+## dataset Objects
+
+```python
+class dataset()
+```
+
+Creates dataset from input source
+
+<a id="utils.data_augmentation.dataset.__init__"></a>
+
+#### \_\_init\_\_
+
+```python
+def __init__(number_samples: int,
+             name: str,
+             source: str,
+             boundary_conditions: list = None)
+```
+
+
+**Arguments**:
+
+- `number_samples` _int_ - number of samples to be genarated
+- `name` _str_ - name of dataset
+- `source` _str_ - source file
+- `boundary_conditions` _list_ - y1,y2,x1,x2
+
+<a id="utils.data_augmentation.dataset.generate"></a>
+
+#### generate
+
+```python
+def generate()
+```
+
+The function takes in a dataframe, normalizes it, and then trains a DCGAN on it. 
+
+The DCGAN is a type of generative adversarial network (GAN) that is used to generate new data. 
+
+The DCGAN is trained on the normalized dataframe, and then the DCGAN is used to generate new
+data. 
+
+The new data is then concatenated with the original dataframe, and the new dataframe is saved as
+a pickle file. 
+
+The new dataframe is then returned.
+
+**Returns**:
+
+The dataframe is being returned.
+
+<a id="nets"></a>
+
+# :orange[nets]
+
+<a id="nets.envs"></a>
+
+# nets.envs
+
+<a id="nets.envs.SCI"></a>
+
+## SCI Objects
+
+```python
+class SCI()
+```
+
+Scaled computing interface.
+
+**Arguments**:
+
+- `hidden_dim` _int, optional_ - Max demension of hidden linear layer. Defaults to 200. Should be >80 in not 1d case
+- `dropout` _bool, optional_ - LEGACY, don't use. Defaults to True.
+- `epochs` _int, optional_ - Optionally specify epochs here, but better in train. Defaults to 10.
+- `dataset` _str, optional_ - dataset to be selected from ./data. Defaults to 'test.pkl'. If name not exists, code will generate new dataset with upcoming parameters.
+- `sample_size` _int, optional_ - Samples to be generated (note: BEFORE applying boundary conditions). Defaults to 1000.
+- `source` _str, optional_ - Source from which data will be generated. Better to not change. Defaults to 'dataset.csv'.
+- `boundary_conditions` _list, optional_ - If sepcified, whole dataset will be cut rectangulary. Input list is [ymin,ymax,xmin,xmax] type. Defaults to None.
+
+<a id="nets.envs.SCI.__init__"></a>
+
+#### \_\_init\_\_
+
+```python
+def __init__(hidden_dim: int = 200,
+             dropout: bool = True,
+             epochs: int = 10,
+             dataset: str = 'test.pkl',
+             sample_size: int = 1000,
+             source: str = 'dataset.csv',
+             boundary_conditions: list = None,
+             batch_size: int = 20)
+```
+
+
+
+**Arguments**:
+
+- `hidden_dim` _int, optional_ - Max demension of hidden linear layer. Defaults to 200. Should be >80 in not 1d case
+- `dropout` _bool, optional_ - LEGACY, don't use. Defaults to True.
+- `epochs` _int, optional_ - Optionally specify epochs here, but better in train. Defaults to 10.
+- `dataset` _str, optional_ - dataset to be selected from ./data. Defaults to 'test.pkl'. If name not exists, code will generate new dataset with upcoming parameters.
+- `sample_size` _int, optional_ - Samples to be generated (note: BEFORE applying boundary conditions). Defaults to 1000.
+- `source` _str, optional_ - Source from which data will be generated. Better to not change. Defaults to 'dataset.csv'.
+- `boundary_conditions` _list, optional_ - If sepcified, whole dataset will be cut rectangulary. Input list is [ymin,ymax,xmin,xmax] type. Defaults to None.
+- `batch_size` _int, optional_ - Batch size for training.
+
+<a id="nets.envs.SCI.feature_gen"></a>
+
+#### feature\_gen
+
+```python
+def feature_gen(base: bool = True,
+                fname: str = None,
+                index: int = None,
+                func=None) -> None
+```
+
+Generate new features. If base true, generates most obvious ones. You can customize this by adding
+new feature as name of column - fname, index of parent column, and lambda function which needs to be applied elementwise.
+
+**Arguments**:
+
+- `base` _bool, optional_ - Defaults to True.
+- `fname` _str, optional_ - Name of new column. Defaults to None.
+- `index` _int, optional_ - Index of parent column. Defaults to None.
+- `func` __type_, optional_ - lambda function. Defaults to None.
+
+<a id="nets.envs.SCI.feature_importance"></a>
+
+#### feature\_importance
+
+```python
+def feature_importance(X: pd.DataFrame, Y: pd.Series, verbose: int = 1)
+```
+
+Gets feature importance by SGD regression and score selection. Default threshold is 1.25*mean
+input X as self.df.iloc[:,(columns of choice)]
+Y as self.df.iloc[:,(column of choice)]
+
+**Arguments**:
+
+- `X` _pd.DataFrame_ - Builtin DataFrame
+- `Y` _pd.Series_ - Builtin Series
+- `verbose` _int, optional_ - either to or to not print actual report. Defaults to 1.
+
+**Returns**:
+
+  Report (str)
+
+<a id="nets.envs.SCI.data_flow"></a>
+
+#### data\_flow
+
+```python
+def data_flow(columns_idx: tuple = (1, 3, 3, 5),
+              idx: tuple = None,
+              split_idx: int = 800) -> torch.utils.data.DataLoader
+```
+
+Data prep pipeline
+It is called automatically, don't call it in your code.
+
+**Arguments**:
+
+- `columns_idx` _tuple, optional_ - Columns to be selected (sliced 1:2 3:4) for feature fitting. Defaults to (1,3,3,5).
+- `idx` _tuple, optional_ - 2|3 indexes to be selected for feature fitting. Defaults to None. Use either idx or columns_idx (for F:R->R idx, for F:R->R2 columns_idx)
+  split_idx (int) : Index to split for training
+  
+
+**Returns**:
+
+- `torch.utils.data.DataLoader` - Torch native dataloader
+
+<a id="nets.envs.SCI.init_seed"></a>
+
+#### init\_seed
+
+```python
+def init_seed(seed)
+```
+
+Initializes seed for torch - optional
+
+<a id="nets.envs.SCI.train_epoch"></a>
+
+#### train\_epoch
+
+```python
+def train_epoch(X, model, loss_function, optim)
+```
+
+Inner function of class - don't use.
+
+We iterate through the data, calculate the loss, backpropagate, and update the weights
+
+**Arguments**:
+
+- `X`: the training data
+- `model`: the model we're training
+- `loss_function`: the loss function to use
+- `optim`: the optimizer, which is the algorithm that will update the weights of the model
+
+<a id="nets.envs.SCI.compile"></a>
+
+#### compile
+
+```python
+def compile(columns: tuple = None,
+            idx: tuple = None,
+            optim: torch.optim = torch.optim.AdamW,
+            loss: nn = nn.L1Loss,
+            model: nn.Module = dmodel,
+            custom: bool = False,
+            lr: float = 0.0001) -> None
+```
+
+Builds model, loss, optimizer. Has defaults
+
+**Arguments**:
+
+- `columns` _tuple, optional_ - Columns to be selected for feature fitting. Defaults to (1,3,3,5).
+- `optim` - torch Optimizer. Default AdamW
+- `loss` - torch Loss function (nn). Defaults to L1Loss
+
+<a id="nets.envs.SCI.train"></a>
+
+#### train
+
+```python
+def train(epochs: int = 10) -> None
+```
+
+Train model
+- If sklearn instance uses .fit()
+
+- epochs (int,optional)
+
+<a id="nets.envs.SCI.save"></a>
+
+#### save
+
+```python
+def save(name: str = 'model.pt') -> None
+```
+
+> This function saves the model to a file
+
+**Arguments**:
+
+- `name` (`str (optional)`): The name of the file to save the model to, defaults to model.pt
+
+<a id="nets.envs.SCI.onnx_export"></a>
+
+#### onnx\_export
+
+```python
+def onnx_export(path: str = './models/model.onnx')
+```
+
+> We are exporting the model to the ONNX format, using the input data and the model itself
+
+**Arguments**:
+
+- `path` (`str (optional)`): The path to save the model to, defaults to ./models/model.onnx
+
+<a id="nets.envs.SCI.jit_export"></a>
+
+#### jit\_export
+
+```python
+def jit_export(path: str = './models/model.pt')
+```
+
+Exports properly defined model to jit
+
+**Arguments**:
+
+- `path` _str, optional_ - path to models. Defaults to './models/model.pt'.
+
+<a id="nets.envs.SCI.inference"></a>
+
+#### inference
+
+```python
+def inference(X: tensor, model_name: str = None) -> np.ndarray
+```
+
+Inference of (pre-)trained model
+
+**Arguments**:
+
+- `X` _tensor_ - your data in domain of train
+
+**Returns**:
+
+- `np.ndarray` - predictions
+
+<a id="nets.envs.SCI.plot"></a>
+
+#### plot
+
+```python
+def plot()
+```
+
+> If the input and output dimensions are the same, plot the input and output as a scatter plot.
+If the input and output dimensions are different, plot the first dimension of the input and
+output as a scatter plot
+
+<a id="nets.envs.SCI.plot3d"></a>
+
+#### plot3d
+
+```python
+def plot3d(colX=0, colY=1)
+```
+
+Plot of inputs and predicted data in mesh format
+
+**Returns**:
+
+  plotly plot
+
+<a id="nets.envs.SCI.performance"></a>
+
+#### performance
+
+```python
+def performance(c=0.4) -> dict
+```
+
+Automatic APE based performance if applicable, else returns nan
+
+**Arguments**:
+
+- `c` _float, optional_ - ZDE mitigation constant. Defaults to 0.4.
+
+**Returns**:
+
+- `dict` - {'Generator_Accuracy, %':np.mean(a),'APE_abs, %':abs_ape,'Model_APE, %': ape}
+
+<a id="nets.envs.SCI.performance_super"></a>
+
+#### performance\_super
+
+```python
+def performance_super(c=0.4,
+                      real_data_column_index: tuple = (1, 8),
+                      real_data_samples: int = 23,
+                      generated_length: int = 1000) -> dict
+```
+
+Performance by custom parameters. APE loss
+
+**Arguments**:
+
+- `c` _float, optional_ - ZDE mitigation constant. Defaults to 0.4.
+- `real_data_column_index` _tuple, optional_ - Defaults to (1,8).
+- `real_data_samples` _int, optional_ - Defaults to 23.
+- `generated_length` _int, optional_ - Defaults to 1000.
+
+**Returns**:
+
+- `dict` - {'Generator_Accuracy, %':np.mean(a),'APE_abs, %':abs_ape,'Model_APE, %': ape}
+
+<a id="nets.envs.RCI"></a>
+
+## RCI Objects
+
+```python
+class RCI(SCI)
+```
+
+Real values interface, uses different types of NN, NO scaling.
+Parent:
+    SCI()
+
+<a id="nets.envs.RCI.data_flow"></a>
+
+#### data\_flow
+
+```python
+def data_flow(columns_idx: tuple = (1, 3, 3, 5),
+              idx: tuple = None,
+              split_idx: int = 800) -> torch.utils.data.DataLoader
+```
+
+Data prep pipeline
+
+**Arguments**:
+
+- `columns_idx` _tuple, optional_ - Columns to be selected (sliced 1:2 3:4) for feature fitting. Defaults to (1,3,3,5).
+- `idx` _tuple, optional_ - 2|3 indexes to be selected for feature fitting. Defaults to None. Use either idx or columns_idx (for F:R->R idx, for F:R->R2 columns_idx)
+  split_idx (int) : Index to split for training
+  
+
+**Returns**:
+
+- `torch.utils.data.DataLoader` - Torch native dataloader
+
+<a id="nets.envs.RCI.compile"></a>
+
+#### compile
+
+```python
+def compile(columns: tuple = None,
+            idx: tuple = (3, 1),
+            optim: torch.optim = torch.optim.AdamW,
+            loss: nn = nn.L1Loss,
+            model: nn.Module = PINNd_p,
+            lr: float = 0.001) -> None
+```
+
+Builds model, loss, optimizer. Has defaults
+
+**Arguments**:
+
+- `columns` _tuple, optional_ - Columns to be selected for feature fitting. Defaults to None.
+- `idx` _tuple, optional_ - indexes to be selected Default (3,1)
+  optim - torch Optimizer
+  loss - torch Loss function (nn)
+
+<a id="nets.envs.RCI.plot"></a>
+
+#### plot
+
+```python
+def plot()
+```
+
+Plots 2d plot of prediction vs real values
+
+<a id="nets.envs.RCI.performance"></a>
+
+#### performance
+
+```python
+def performance(c=0.4) -> dict
+```
+
+RCI performnace. APE errors.
+
+**Arguments**:
+
+- `c` _float, optional_ - correction constant to mitigate division by 0 error. Defaults to 0.4.
+
+**Returns**:
+
+- `dict` - {'Generator_Accuracy, %':np.mean(a),'APE_abs, %':abs_ape,'Model_APE, %': ape}
+
+<a id="nets.dense"></a>
+
+# nets.dense
+
+<a id="nets.dense.Net"></a>
+
+## Net Objects
+
+```python
+class Net(nn.Module)
+```
+
+The Net class inherits from the nn.Module class, which has a number of attributes and methods (such
+as .parameters() and .zero_grad()) which we will be using. You can read more about the nn.Module
+class [here](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)
+
+<a id="nets.dense.Net.__init__"></a>
+
+#### \_\_init\_\_
+
+```python
+def __init__(input_dim: int = 2, hidden_dim: int = 200)
+```
+
+We create a neural network with two hidden layers, each with **hidden_dim** neurons, and a ReLU activation
+
+function. The output layer has one neuron and no activation function
+
+**Arguments**:
+
+- `input_dim` (`int (optional)`): The dimension of the input, defaults to 2
+- `hidden_dim` (`int (optional)`): The number of neurons in the hidden layer, defaults to 200
+
+<a id="nets.design"></a>
+
+# nets.design
+
+<a id="nets.design.B_field_norm"></a>
+
+#### B\_field\_norm
+
+```python
+def B_field_norm(Bmax: float, L: float, k: int = 16, plot=True) -> np.array
+```
+
+Returns vec B_z for MS config
+
+**Arguments**:
+
+- `Bmax` _any_ - maximum B in thruster
+  L - channel length
+  k - magnetic field profile number
+
+<a id="nets.design.PUdesign"></a>
+
+#### PUdesign
+
+```python
+def PUdesign(P: float, U: float) -> pd.DataFrame
+```
+
+Computes design via numerical model, uses fits from PINNs
+
+**Arguments**:
+
+- `P` _float_ - _description_
+- `U` _float_ - _description_
+  
+
+**Returns**:
+
+- `_type_` - _description_
+
+<a id="nets.deep_dense"></a>
+
+# nets.deep\_dense
+
+<a id="nets.deep_dense.dmodel"></a>
+
+## dmodel Objects
+
+```python
+class dmodel(nn.Module)
+```
+
+<a id="nets.deep_dense.dmodel.__init__"></a>
+
+#### \_\_init\_\_
+
+```python
+def __init__(in_features=1, hidden_features=200, out_features=1)
+```
+
+We're creating a neural network with 4 layers, each with 200 neurons. The first layer takes in the input, the second layer takes in the output of the first layer, the third layer takes in the
+output of the second layer, and the fourth layer takes in the output of the third layer
+
+**Arguments**:
+
+- `in_features`: The number of input features, defaults to 1 (optional)
+- `hidden_features`: the number of neurons in the hidden layers, defaults to 200 (optional)
+- `out_features`: The number of classes for classification (1 for regression), defaults to 1
+(optional)
+
+<a id="nets.opti"></a>
+
+# nets.opti
+
+<a id="nets.opti.blackbox"></a>
+
+# nets.opti.blackbox
+
+<a id="nets.opti.blackbox.Hyper"></a>
+
+## Hyper Objects
+
+```python
+class Hyper(SCI)
+```
+
+Hyper parameter tunning class. Allows to generate best NN architecture for task. Inputs are column indexes. idx[-1] is targeted value.
+Based on OPTUNA algorithms it is very fast and reliable. Outputs are NN parameters in json. Optionally full report for every trial is available at the neptune.ai
+
+<a id="nets.opti.blackbox.Hyper.__init__"></a>
+
+#### \_\_init\_\_
+
+```python
+def __init__(idx: tuple = (1, 3, 7), *args, **kwargs)
+```
+
+The function __init__() is a constructor that initializes the class Hyper
+
+**Arguments**:
+
+- `idx` (`tuple`): tuple of integers, the indices of the data to be loaded
+
+<a id="nets.opti.blackbox.Hyper.define_model"></a>
+
+#### define\_model
+
+```python
+def define_model(trial)
+```
+
+We define a function that takes in a trial object and returns a neural network with the number
+
+of layers, hidden units and activation functions defined by the trial object.
+
+**Arguments**:
+
+- `trial`: This is an object that contains the information about the current trial
+
+**Returns**:
+
+A sequential model with the number of layers, hidden units and activation functions
+defined by the trial.
+
+<a id="nets.opti.blackbox.Hyper.objective"></a>
+
+#### objective
+
+```python
+def objective(trial)
+```
+
+We define a model, an optimizer, and a loss function. We then train the model for a number of
+
+epochs, and report the loss at the end of each epoch
+
+*"optimizer": ["Adam", "RMSprop", "SGD" 'AdamW','Adamax','Adagrad']*
+*"lr" $\in$ [1e-7,1e-3], log=True*
+
+**Arguments**:
+
+- `trial`: The trial object that is passed to the objective function
+
+**Returns**:
+
+The accuracy of the model.
+
+<a id="nets.opti.blackbox.Hyper.start_study"></a>
+
+#### start\_study
+
+```python
+def start_study(n_trials: int = 100,
+                neptune_project: str = None,
+                neptune_api: str = None)
+```
+
+It takes a number of trials, a neptune project name and a neptune api token as input and runs
+
+the objective function on the number of trials specified. If the neptune project and api token
+are provided, it logs the results to neptune
+
+**Arguments**:
+
+- `n_trials` (`int (optional)`): The number of trials to run, defaults to 100
+- `neptune_project` (`str`): the name of the neptune project you want to log to
+- `neptune_api` (`str`): your neptune api key
+

main.py

@@ -0,0 +1,83 @@
+import streamlit as st
+
+from nets.envs import SCI
+
+
+st.set_page_config(
+        page_title="HET_sci",
+        menu_items={
+            'About':'https://advpropsys.github.io'
+        }
+)
+
+st.title('HETfit_scientific')
+st.markdown("#### Imagine a package which was engineered primarly for data driven plasma physics devices design, mainly low power hall effect thrusters, yup that's it"
+            "\n### :orange[Don't be scared away though, it has much simpler interface than anything you ever used for such designs]")
+st.markdown('### Main concepts:')
+st.markdown( "- Each observational/design session is called an **environment**, for now it can be either RCI or SCI (Real or scaled interface)"
+            "\n In this overview we will only touch SCI, since RCI is using PINNs which are different topic"
+            "\n- You specify most of the run parameters on this object init, :orange[**including generation of new samples**] via GAN"
+            "\n- You may want to generate new features, do it !"
+            "\n- Want to select best features for more effctive work? Done!"
+            "\n- Compile environment with your model of choice, can be ***any*** torch model or sklearn one"
+            "\n- Train !"
+            "\n- Plot, inference, save, export to jit/onnx, measure performance - **they all are one liners** "
+            )
+st.markdown('### tl;dr \n- Create environment'
+            '\n```run = SCI(*args,**kwargs)```'
+            '\n - Generate features ```run.feature_gen()``` '
+            '\n - Select features ```run.feature_importance()```'
+            '\n - Compile env ```run.compile()```'
+            '\n - Train model in env ```run.train()```'
+            '\n - Inference, plot, performance, ex. ```run.plot3d()```'
+            '\n #### And yes, it all will work even without any additional arguments from user besides column indexes'
+            )
+st.write('Comparison with *arXiv:2206.04440v3*')
+col1, col2 = st.columns(2)
+col1.metric('Geometry accuracy on domain',value='83%',delta='15%')
+col2.metric('$d \mapsto h$ prediction',value='98%',delta='14%')
+
+st.header('Example:')
+
+st.markdown('Remeber indexes and column names on this example: $P$ - 1, $d$ - 3, $h$ - 3, $m_a$ - 6,$T$ - 7')
+st.code('run = SCI(*args,**kwargs)')
+
+run = SCI()
+st.code('run.feature_gen()')
+run.feature_gen()
+st.write('New features: (index-0:22 original samples, else is GAN generated)',run.df.iloc[1:,9:].astype(float))
+st.write('Most of real dataset is from *doi:0.2514/1.B37424*, hence the results mostly agree with it in specific')
+st.code('run.feature_importance(run.df.iloc[1:,1:7].astype(float),run.df.iloc[1:,7]) # Clear and easy example')
+
+st.write(run.feature_importance(run.df.iloc[1:,1:6].astype(float),run.df.iloc[1:,6]))
+st.markdown(' As we can see only $h$ and $d$ passed for $m_a$ model, not only that linear dependacy was proven experimantally, but now we got this from data driven source')
+st.code('run.compile(idx=(1,3,7))')
+run.compile(idx=(1,3,7))
+st.code('run.train(epochs=10)')
+if st.button('Start Training⏳',use_container_width=True):
+    run.train(epochs=10)
+    st.code('run.plot3d()')
+    st.write(run.plot3d())
+    st.code('run.performance()')
+    st.write(run.performance())
+else:
+    st.markdown('#')
+    
+st.markdown('---\nTry it out yourself! Select a column from 1 to 10')
+
+
+number = st.number_input('Here',min_value=1, max_value=10, step=1)
+
+if number:
+    if st.button('Compile And Train💅',use_container_width=True):
+        st.code(f'run.compile(idx=(1,3,{number}))')
+        run.compile(idx=(1,3,number))
+        st.code('run.train(epochs=10)')
+        run.train(epochs=10)
+        st.code('run.plot3d()')
+        st.write(run.plot3d())
+
+
+
+st.markdown('In this intro we covered simplest userflow while using HETFit package, resulted data can be used to leverage PINN and analytical models of Hall effect thrusters'
+            '\n #### :orange[To cite please contact author on https://github.com/advpropsys]')

module_name.md

@@ -0,0 +1,456 @@
+# Table of Contents
+
+- [Table of Contents](#table-of-contents)
+- [main](#main)
+- [:orange\[PINN\]](#orangepinn)
+  - [PINN.pinns](#pinnpinns)
+  - [PINNd\_p Objects](#pinnd_p-objects)
+  - [PINNhd\_ma Objects](#pinnhd_ma-objects)
+  - [PINNT\_ma Objects](#pinnt_ma-objects)
+- [:orange\[utils\]](#orangeutils)
+  - [utils.test](#utilstest)
+  - [utils.dataset\_loader](#utilsdataset_loader)
+      - [get\_dataset](#get_dataset)
+  - [utils.ndgan](#utilsndgan)
+    - [DCGAN Objects](#dcgan-objects)
+      - [define\_discriminator](#define_discriminator)
+      - [generate\_latent\_points](#generate_latent_points)
+      - [define\_gan](#define_gan)
+      - [summarize\_performance](#summarize_performance)
+      - [train\_gan](#train_gan)
+  - [utils.data\_augmentation](#utilsdata_augmentation)
+  - [dataset Objects](#dataset-objects)
+      - [\_\_init\_\_](#__init__)
+- [:orange\[nets\]](#orangenets)
+  - [nets.envs](#netsenvs)
+    - [SCI Objects](#sci-objects)
+      - [data\_flow](#data_flow)
+      - [init\_seed](#init_seed)
+      - [compile](#compile)
+      - [train](#train)
+      - [inference](#inference)
+    - [RCI Objects](#rci-objects)
+      - [data\_flow](#data_flow-1)
+      - [compile](#compile-1)
+  - [nets.dense](#netsdense)
+    - [Net Objects](#net-objects)
+      - [\_\_init\_\_](#__init__-1)
+  - [nets.design](#netsdesign)
+      - [B\_field\_norm](#b_field_norm)
+  - [nets.deep\_dense](#netsdeep_dense)
+    - [dmodel Objects](#dmodel-objects)
+      - [\_\_init\_\_](#__init__-2)
+
+<a id="main"></a>
+
+# main
+
+<a id="PINN"></a>
+
+# :orange[PINN]
+
+<a id="PINN.pinns"></a>
+
+## PINN.pinns
+
+<a id="PINN.pinns.PINNd_p"></a>
+
+## PINNd\_p Objects
+
+```python
+class PINNd_p(nn.Module)
+```
+
+$d \mapsto P$
+
+<a id="PINN.pinns.PINNhd_ma"></a>
+
+## PINNhd\_ma Objects
+
+```python
+class PINNhd_ma(nn.Module)
+```
+
+$h,d \mapsto m_a $
+
+<a id="PINN.pinns.PINNT_ma"></a>
+
+## PINNT\_ma Objects
+
+```python
+class PINNT_ma(nn.Module)
+```
+
+$ m_a, U \mapsto T$
+
+<a id="utils"></a>
+
+---
+# :orange[utils]
+
+<a id="utils.test"></a>
+
+## utils.test
+
+<a id="utils.dataset_loader"></a>
+
+## utils.dataset\_loader
+
+<a id="utils.dataset_loader.get_dataset"></a>
+
+#### get\_dataset
+
+```python
+def get_dataset(raw: bool = False,
+                sample_size: int = 1000,
+                name: str = 'dataset.pkl',
+                source: str = 'dataset.csv',
+                boundary_conditions: list = None) -> _pickle
+```
+
+Gets augmented dataset
+
+**Arguments**:
+
+- `raw` _bool, optional_ - either to use source data or augmented. Defaults to False.
+- `sample_size` _int, optional_ - sample size. Defaults to 1000.
+- `name` _str, optional_ - name of wanted dataset. Defaults to 'dataset.pkl'.
+- `boundary_conditions` _list,optional_ - y1,y2,x1,x2.
+
+**Returns**:
+
+- `_pickle` - pickle buffer
+
+<a id="utils.ndgan"></a>
+
+## utils.ndgan
+
+<a id="utils.ndgan.DCGAN"></a>
+
+### DCGAN Objects
+
+```python
+class DCGAN()
+```
+
+<a id="utils.ndgan.DCGAN.define_discriminator"></a>
+
+#### define\_discriminator
+
+```python
+def define_discriminator(inputs=8)
+```
+
+function to return the compiled discriminator model
+
+<a id="utils.ndgan.DCGAN.generate_latent_points"></a>
+
+#### generate\_latent\_points
+
+```python
+def generate_latent_points(latent_dim, n)
+```
+
+generate points in latent space as input for the generator
+
+<a id="utils.ndgan.DCGAN.define_gan"></a>
+
+#### define\_gan
+
+```python
+def define_gan(generator, discriminator)
+```
+
+define the combined generator and discriminator model
+
+<a id="utils.ndgan.DCGAN.summarize_performance"></a>
+
+#### summarize\_performance
+
+```python
+def summarize_performance(epoch, generator, discriminator, latent_dim, n=200)
+```
+
+evaluate the discriminator and plot real and fake samples
+
+<a id="utils.ndgan.DCGAN.train_gan"></a>
+
+#### train\_gan
+
+```python
+def train_gan(g_model,
+              d_model,
+              gan_model,
+              latent_dim,
+              num_epochs=2500,
+              num_eval=2500,
+              batch_size=2)
+```
+
+function to train gan model
+
+<a id="utils.data_augmentation"></a>
+
+## utils.data\_augmentation
+
+<a id="utils.data_augmentation.dataset"></a>
+
+## dataset Objects
+
+```python
+class dataset()
+```
+
+Creates dataset from input source
+
+<a id="utils.data_augmentation.dataset.__init__"></a>
+
+#### \_\_init\_\_
+
+```python
+def __init__(number_samples: int,
+             name: str,
+             source: str,
+             boundary_conditions: list = None)
+```
+
+_summary_
+
+**Arguments**:
+
+- `number_samples` _int_ - _description_
+- `name` _str_ - _description_
+- `source` _str_ - _description_
+- `boundary_conditions` _list_ - y1,y2,x1,x2
+
+<a id="nets"></a>
+
+# :orange[nets]
+
+<a id="nets.envs"></a>
+
+## nets.envs
+
+<a id="nets.envs.SCI"></a>
+
+### SCI Objects
+
+```python
+class SCI()
+```
+
+<a id="nets.envs.SCI.data_flow"></a>
+
+#### data\_flow
+
+```python
+def data_flow(columns_idx: tuple = (1, 3, 3, 5),
+              idx: tuple = None,
+              split_idx: int = 800) -> torch.utils.data.DataLoader
+```
+
+Data prep pipeline
+
+**Arguments**:
+
+- `columns_idx` _tuple, optional_ - Columns to be selected (sliced 1:2 3:4) for feature fitting. Defaults to (1,3,3,5).
+- `idx` _tuple, optional_ - 2|3 indexes to be selected for feature fitting. Defaults to None. Use either idx or columns_idx (for F:R->R idx, for F:R->R2 columns_idx)
+  split_idx (int) : Index to split for training
+  
+
+**Returns**:
+
+- `torch.utils.data.DataLoader` - Torch native dataloader
+
+<a id="nets.envs.SCI.init_seed"></a>
+
+#### init\_seed
+
+```python
+def init_seed(seed)
+```
+
+Initializes seed for torch optional()
+
+<a id="nets.envs.SCI.compile"></a>
+
+#### compile
+
+```python
+def compile(columns: tuple = None,
+            idx: tuple = None,
+            optim: torch.optim = torch.optim.AdamW,
+            loss: nn = nn.L1Loss,
+            model: nn.Module = dmodel,
+            custom: bool = False) -> None
+```
+
+Builds model, loss, optimizer. Has defaults
+
+**Arguments**:
+
+- `columns` _tuple, optional_ - Columns to be selected for feature fitting. Defaults to (1,3,3,5).
+  optim - torch Optimizer
+  loss - torch Loss function (nn)
+
+<a id="nets.envs.SCI.train"></a>
+
+#### train
+
+```python
+def train(epochs: int = 10) -> None
+```
+
+Train model
+If sklearn instance uses .fit()
+
+<a id="nets.envs.SCI.inference"></a>
+
+#### inference
+
+```python
+def inference(X: tensor, model_name: str = None) -> np.ndarray
+```
+
+Inference of (pre-)trained model
+
+**Arguments**:
+
+- `X` _tensor_ - your data in domain of train
+  
+
+**Returns**:
+
+- `np.ndarray` - predictions
+
+<a id="nets.envs.RCI"></a>
+
+### RCI Objects
+
+```python
+class RCI(SCI)
+```
+
+<a id="nets.envs.RCI.data_flow"></a>
+
+#### data\_flow
+
+```python
+def data_flow(columns_idx: tuple = (1, 3, 3, 5),
+              idx: tuple = None,
+              split_idx: int = 800) -> torch.utils.data.DataLoader
+```
+
+Data prep pipeline
+
+**Arguments**:
+
+- `columns_idx` _tuple, optional_ - Columns to be selected (sliced 1:2 3:4) for feature fitting. Defaults to (1,3,3,5).
+- `idx` _tuple, optional_ - 2|3 indexes to be selected for feature fitting. Defaults to None. Use either idx or columns_idx (for F:R->R idx, for F:R->R2 columns_idx)
+  split_idx (int) : Index to split for training
+  
+
+**Returns**:
+
+- `torch.utils.data.DataLoader` - Torch native dataloader
+
+<a id="nets.envs.RCI.compile"></a>
+
+#### compile
+
+```python
+def compile(columns: tuple = None,
+            idx: tuple = (3, 1),
+            optim: torch.optim = torch.optim.AdamW,
+            loss: nn = nn.L1Loss,
+            model: nn.Module = PINNd_p,
+            lr: float = 0.001) -> None
+```
+
+Builds model, loss, optimizer. Has defaults
+
+**Arguments**:
+
+- `columns` _tuple, optional_ - Columns to be selected for feature fitting. Defaults to None.
+- `idx` _tuple, optional_ - indexes to be selected Default (3,1)
+  optim - torch Optimizer
+  loss - torch Loss function (nn)
+
+<a id="nets.dense"></a>
+
+## nets.dense
+
+<a id="nets.dense.Net"></a>
+
+### Net Objects
+
+```python
+class Net(nn.Module)
+```
+
+4 layer model, different activations and neurons count on layer
+
+<a id="nets.dense.Net.__init__"></a>
+
+#### \_\_init\_\_
+
+```python
+def __init__(input_dim: int = 2, hidden_dim: int = 200)
+```
+
+Init
+
+**Arguments**:
+
+- `input_dim` _int, optional_ - Defaults to 2.
+- `hidden_dim` _int, optional_ - Defaults to 200.
+
+<a id="nets.design"></a>
+
+## nets.design
+
+<a id="nets.design.B_field_norm"></a>
+
+#### B\_field\_norm
+
+```python
+def B_field_norm(Bmax, L, k=16, plot=True)
+```
+
+Returns vec B_z
+
+**Arguments**:
+
+- `Bmax` _any_ - maximum B in thruster
+  k - magnetic field profile number
+
+<a id="nets.deep_dense"></a>
+
+## nets.deep\_dense
+
+<a id="nets.deep_dense.dmodel"></a>
+
+### dmodel Objects
+
+```python
+class dmodel(nn.Module)
+```
+
+4 layers Torch model. Relu activations, hidden layers are same size.
+
+<a id="nets.deep_dense.dmodel.__init__"></a>
+
+#### \_\_init\_\_
+
+```python
+def __init__(in_features=1, hidden_features=200, out_features=1)
+```
+
+Init
+
+**Arguments**:
+
+- `in_features` _int, optional_ - Input features. Defaults to 1.
+- `hidden_features` _int, optional_ - Hidden dims. Defaults to 200.
+- `out_features` _int, optional_ - Output dims. Defaults to 1.
+

nets/deep_dense.py

@@ -0,0 +1,32 @@
+from torch import nn
+from torch.functional import F
+
+class dmodel(nn.Module):
+    """4 layers Torch model. Relu activations, hidden layers are same size.
+
+    """
+    def __init__(self, in_features=1, hidden_features=200, out_features=1):
+        """Init
+
+        Args:
+            in_features (int, optional): Input features. Defaults to 1.
+            hidden_features (int, optional): Hidden dims. Defaults to 200.
+            out_features (int, optional): Output dims. Defaults to 1.
+        """
+        super(dmodel, self).__init__()
+        
+        self.fc1 = nn.Linear(in_features, hidden_features)
+        self.fc2 = nn.Linear(hidden_features, hidden_features)
+        self.fc3 = nn.Linear(hidden_features, hidden_features)
+        self.fc4 = nn.Linear(hidden_features, out_features)
+                
+        
+    def forward(self, x):
+        x = self.fc1(x)
+        x = F.relu(x) # ReLU activation
+        x = self.fc2(x)
+        x = F.relu(x) # ReLU activation
+        x = self.fc3(x)
+        x = F.relu(x) # ReLU activation
+        x = self.fc4(x)
+        return x

nets/dense.py

@@ -0,0 +1,27 @@
+from torch import nn
+
+class Net(nn.Module):
+    """4 layer model, different activations and neurons count on layer
+
+    """
+    def __init__(self,input_dim:int=2,hidden_dim:int=200):
+        """Init
+
+        Args:
+            input_dim (int, optional): Defaults to 2.
+            hidden_dim (int, optional): Defaults to 200.
+        """
+        super(Net,self).__init__()
+        self.input = nn.Linear(input_dim,40)
+        self.act1 = nn.Tanh()
+        self.layer = nn.Linear(40,80)
+        self.act2 = nn.ReLU()
+        self.layer1 = nn.Linear(80,hidden_dim)
+        self.act3 = nn.ReLU()
+        self.layer2 = nn.Linear(hidden_dim,1)
+        
+    def forward(self, x):
+        x = self.act2(self.layer(self.act1(self.input(x))))
+        x = self.act3(self.layer1(x))
+        x = self.layer2(x)
+        return x

nets/design.py

@@ -0,0 +1,42 @@
+import numpy as np
+import seaborn as sns
+import pandas as pd
+
+def B_field_norm(Bmax:float,L:float,k:int=16,plot=True) -> np.array:
+    """ Returns vec B_z for MS config
+
+    Args:
+        Bmax (any): maximum B in thruster
+        L - channel length
+        k - magnetic field profile number
+    """
+    z = np.linspace(0,L*1.4,200)
+    B = Bmax * np.exp(-k * (z/(1.2*L) - 1)**2)
+    if plot:
+        sns.lineplot(x=z,y=B)
+    return z,B
+
+def PUdesign(P:float,U:float) -> pd.DataFrame:
+    """Computes design via numerical model, uses fits from PINNs
+
+    Args:
+        P (float): _description_
+        U (float): _description_
+
+    Returns:
+        _type_: _description_
+    """
+    d = np.sqrt(P/(635*U))
+    h = 0.245*d
+    m_a = 0.0025*h*d
+    T = 890 * m_a * np.sqrt(U)
+    j = P/(np.pi*d*h)
+    Isp = T/(m_a*9.81) 
+    nu_t = T*Isp*9.81/(2*P)
+    df = pd.DataFrame([[d,h,m_a,T,j,nu_t,Isp]],columns=['d','h','m_a','T','j','nu_t','Isp'])
+    g = sns.barplot(df,facecolor='gray')
+    g.set_yscale("log")
+    return df
+    
+def cathode_erosion():
+    pass

nets/envs.py

@@ -0,0 +1,491 @@
+from utils.dataset_loader import get_dataset
+from nets.dense import Net
+from nets.deep_dense import dmodel
+from PINN.pinns import *
+
+import matplotlib.pyplot as plt
+import seaborn as sns
+import torch
+import os
+import numpy as np
+from torch import nn, tensor
+import pandas as pd
+import plotly.express as px
+from sklearn.linear_model import SGDRegressor
+from sklearn.feature_selection import SelectFromModel
+
+class SCI(): #Scaled Computing Interface
+    """ Scaled computing interface.
+    Args:
+            hidden_dim (int, optional): Max demension of hidden linear layer. Defaults to 200. Should be >80 in not 1d case
+            dropout (bool, optional): LEGACY, don't use. Defaults to True.
+            epochs (int, optional): Optionally specify epochs here, but better in train. Defaults to 10.
+            dataset (str, optional): dataset to be selected from ./data. Defaults to 'test.pkl'. If name not exists, code will generate new dataset with upcoming parameters.
+            sample_size (int, optional): Samples to be generated (note: BEFORE applying boundary conditions). Defaults to 1000.
+            source (str, optional): Source from which data will be generated. Better to not change. Defaults to 'dataset.csv'.
+            boundary_conditions (list, optional): If sepcified, whole dataset will be cut rectangulary. Input list is [ymin,ymax,xmin,xmax] type. Defaults to None.
+    """
+    def __init__(self, hidden_dim:int = 200, dropout:bool = True, epochs:int = 10, dataset:str = 'test.pkl',sample_size:int=1000,source:str='dataset.csv',boundary_conditions:list=None):
+        """Init
+        Args:
+            hidden_dim (int, optional): Max demension of hidden linear layer. Defaults to 200. Should be >80 in not 1d case
+            dropout (bool, optional): LEGACY, don't use. Defaults to True.
+            epochs (int, optional): Optionally specify epochs here, but better in train. Defaults to 10.
+            dataset (str, optional): dataset to be selected from ./data. Defaults to 'test.pkl'. If name not exists, code will generate new dataset with upcoming parameters.
+            sample_size (int, optional): Samples to be generated (note: BEFORE applying boundary conditions). Defaults to 1000.
+            source (str, optional): Source from which data will be generated. Better to not change. Defaults to 'dataset.csv'.
+            boundary_conditions (list, optional): If sepcified, whole dataset will be cut rectangulary. Input list is [ymin,ymax,xmin,xmax] type. Defaults to None.
+        """
+        self.type:str = 'legacy'
+        self.seed:int = 449
+        self.dim = hidden_dim
+        self.dropout = dropout
+        self.df = get_dataset(sample_size=sample_size,source=source,name=dataset,boundary_conditions=boundary_conditions)
+        self.epochs = epochs
+        self.len_idx = 0
+        self.input_dim_for_check = 0
+        
+    def feature_gen(self, base:bool=True, fname:str=None,index:int=None,func=None) -> None:
+        """ Generate new features. If base true, generates most obvious ones. You can customize this by adding 
+        new feature as name of column - fname, index of parent column, and lambda function which needs to be applied elementwise.
+        Args:
+            base (bool, optional):  Defaults to True.
+            fname (str, optional): Name of new column. Defaults to None.
+            index (int, optional): Index of parent column. Defaults to None.
+            func (_type_, optional): lambda function. Defaults to None.
+        """
+        
+        if base:
+            self.df['P_sqrt'] = self.df.iloc[:,1].apply(lambda x: x ** 0.5)
+            self.df['j'] = self.df.iloc[:,1]/(self.df.iloc[:,3]*self.df.iloc[:,4])
+            self.df['B'] = self.df.iloc[:,-1].apply(lambda x: x ** 2).apply(lambda x:1 if x>1 else x)
+            self.df['nu_t'] = self.df.iloc[:,7]**2/(2*self.df.iloc[:,6]*self.df.P)
+            
+        if fname and index and func:
+            self.df[fname] = self.df.iloc[:,index].apply(func)
+        
+    def feature_importance(self,X:pd.DataFrame,Y:pd.Series,verbose:int=1):
+        """ Gets feature importance by SGD regression and score selection. Default threshold is 1.25*mean
+        input X as self.df.iloc[:,(columns of choice)]
+              Y as self.df.iloc[:,(column of choice)]
+        Args:
+            X (pd.DataFrame): Builtin DataFrame
+            Y (pd.Series): Builtin Series
+            verbose (int, optional): either to or to not print actual report. Defaults to 1.
+        Returns:
+            Report (str)
+        """
+        
+        mod = SGDRegressor()
+        
+        selector = SelectFromModel(mod,threshold='1.25*mean')
+        selector.fit(np.array(X),np.array(Y))
+        
+        if verbose:
+            print(f'\n Report of feature importance: {dict(zip(X.columns,selector.estimator_.coef_))}')
+        for i in range(len(selector.get_support())):
+            if selector.get_support()[i]:
+                print(f'-rank 1 PASSED:',X.columns[i])
+            else:
+                print(f'-rank 0 REJECT:',X.columns[i])
+        return f'\n Report of feature importance: {dict(zip(X.columns,selector.estimator_.coef_))}'
+        
+    def data_flow(self,columns_idx:tuple = (1,3,3,5), idx:tuple=None, split_idx:int = 800) -> torch.utils.data.DataLoader:
+        """ Data prep pipeline
+        It is called automatically, don't call it in your code.
+        Args:
+            columns_idx (tuple, optional): Columns to be selected (sliced 1:2 3:4) for feature fitting. Defaults to (1,3,3,5). 
+            idx (tuple, optional): 2|3 indexes to be selected for feature fitting. Defaults to None. Use either idx or columns_idx (for F:R->R idx, for F:R->R2 columns_idx)
+            split_idx (int) : Index to split for training
+            
+        Returns:
+            torch.utils.data.DataLoader: Torch native dataloader
+        """
+        batch_size=2
+        
+        self.split_idx=split_idx
+        
+        if idx!=None:
+            self.len_idx = len(idx)
+            if len(idx)==2:
+                self.X = tensor(self.df.iloc[:,idx[0]].values[:split_idx]).float()
+                self.Y = tensor(self.df.iloc[:,idx[1]].values[:split_idx]).float()
+                batch_size = 1
+            else:
+                self.X = tensor(self.df.iloc[:,[*idx[:-1]]].values[:split_idx,:]).float()
+                self.Y = tensor(self.df.iloc[:,idx[2]].values[:split_idx]).float()
+        else:
+            self.X = tensor(self.df.iloc[:,columns_idx[0]:columns_idx[1]].values[:split_idx,:]).float()
+            self.Y = tensor(self.df.iloc[:,columns_idx[2]:columns_idx[3]].values[:split_idx]).float()
+            
+        print('Shapes for debug: (X,Y)',self.X.shape, self.Y.shape)
+        train_data = torch.utils.data.TensorDataset(self.X, self.Y)
+        Xtrain = torch.utils.data.DataLoader(train_data,batch_size=batch_size)
+        self.input_dim = self.X.size(-1)
+        self.indexes = idx if idx else columns_idx
+        self.column_names = [self.df.columns[i] for i in self.indexes]
+        return Xtrain
+        
+    def init_seed(self,seed):
+        """ Initializes seed for torch optional()
+        """
+        
+        torch.manual_seed(seed)
+        
+    def train_epoch(self,X, model, loss_function, optim):
+        for i,data in enumerate(X):
+                Y_pred = model(data[0])
+                loss = loss_function(Y_pred, data[1])
+                
+                # mean_abs_percentage_error = MeanAbsolutePercentageError()
+                # ape = mean_abs_percentage_error(Y_pred, data[1])
+                
+                loss.backward()
+                optim.step()
+                optim.zero_grad()
+            
+                
+                ape_norm = abs(np.mean((Y_pred.detach().numpy()-data[1].detach().numpy())/(data[1].detach().numpy()+0.1)))
+                if (i+1)%200==0:
+                    print(f'Iter {i+1} APE =',ape_norm)
+                self.loss_history.append(loss.data.item())
+                self.ape_history.append(None if ape_norm >1 else ape_norm)
+                
+    def compile(self,columns:tuple=None,idx:tuple=None, optim:torch.optim = torch.optim.AdamW,loss:nn=nn.L1Loss, model:nn.Module = dmodel, custom:bool=False, lr:float=0.0001) -> None:
+        """ Builds model, loss, optimizer. Has defaults
+        Args:
+            columns (tuple, optional): Columns to be selected for feature fitting. Defaults to (1,3,3,5).
+            optim - torch Optimizer. Default AdamW
+            loss - torch Loss function (nn). Defaults to L1Loss
+        """
+        
+        self.columns = columns
+        
+                
+        if not(columns):
+            self.len_idx = 0
+        else:
+            self.len_idx = len(columns)
+            
+        if not(self.columns) and not(idx):
+            self.Xtrain = self.data_flow()
+        elif not(idx): 
+            self.Xtrain = self.data_flow(columns_idx=self.columns)
+        else:
+            self.Xtrain = self.data_flow(idx=idx)
+            
+        if custom:
+            self.model = model()
+            self.loss_function = loss()
+            self.optim = optim(self.model.parameters(), lr=lr)
+            if self.len_idx == 2:
+                self.input_dim_for_check = 1
+        else: 
+            if self.len_idx == 2:
+                self.model = model(in_features=1,hidden_features=self.dim).float()
+                self.input_dim_for_check = 1
+            if self.len_idx == 3:
+                self.model = Net(input_dim=2,hidden_dim=self.dim).float()
+            if (self.len_idx != 2 or 3) or self.columns:
+                self.model = Net(input_dim=self.input_dim,hidden_dim=self.dim).float()
+                
+            self.optim = optim(self.model.parameters(), lr=lr)
+            self.loss_function = loss()
+            
+        if self.input_dim_for_check:
+            self.X  = self.X.reshape(-1,1)
+        
+       
+    
+    def train(self,epochs:int=10) -> None:
+        """ Train model
+        If sklearn instance uses .fit()
+        
+        epochs - optional
+        """
+        if 'sklearn' in str(self.model.__class__):
+            self.model.fit(np.array(self.X),np.array(self.Y))
+            plt.scatter(self.X,self.model.predict(self.X))
+            plt.scatter(self.X,self.Y)
+            plt.xlabel('Xreal')
+            plt.ylabel('Ypred/Yreal')
+            plt.show()
+            return print('Sklearn model fitted successfully')
+        else:
+            self.model.train()
+            
+        self.loss_history = []
+        self.ape_history = []
+        
+        self.epochs = epochs
+        
+        
+        for j in range(self.epochs):
+            self.train_epoch(self.Xtrain,self.model,self.loss_function,self.optim)
+            
+        plt.plot(self.loss_history,label='loss_history')
+        plt.legend()
+            
+    def save(self,name:str='model.pt') -> None:
+        torch.save(self.model,name)
+        
+    def onnx_export(self,path:str='./models/model.onnx'):
+        torch.onnx.export(self.model,self.X,path)
+        
+    def jit_export(self,path:str='./models/model.pt'):
+        """Exports properly defined model to jit
+        Args:
+            path (str, optional): path to models. Defaults to './models/model.pt'.
+        """
+        torch.jit.save(self.model,path)
+        
+    def inference(self,X:tensor, model_name:str=None) -> np.ndarray:
+        """ Inference of (pre-)trained model
+        Args:
+            X (tensor): your data in domain of train
+        Returns:
+            np.ndarray: predictions
+        """
+        if model_name is None:
+            self.model.eval()
+            
+        if model_name in os.listdir('./models'):
+            model = torch.load(f'./models/{model_name}')
+            model.eval()
+            return model(X).detach().numpy()
+        
+        return self.model(X).detach().numpy()
+
+    def plot(self):
+        """ Automatic 2d plot
+        """
+        self.model.eval()
+        print(self.Y.shape,self.model(self.X).detach().numpy().shape,self.X.shape)
+        if self.X.shape[-1] != self.model(self.X).detach().numpy().shape[-1]:
+            print('Size mismatch, try 3d plot, plotting by first dim of largest tensor')
+            if len(self.X.shape)==1:
+                X = self.X
+            else: X = self.X[:,0]
+            plt.scatter(X,self.model(self.X).detach().numpy(),label='predicted',s=2)
+            if len(self.Y.shape)!=1:
+                plt.scatter(X,self.Y[:,1],s=1,label='real')
+            else:
+                plt.scatter(X,self.Y,s=1,label='real')
+            plt.xlabel(rf'${self.column_names[0]}$')
+            plt.ylabel(rf'${self.column_names[1]}$')
+            plt.legend()
+        else:
+            plt.scatter(self.X,self.model(self.X).detach().numpy(),s=2,label='predicted')
+            plt.scatter(self.X,self.Y,s=1,label='real')
+            plt.xlabel(r'$X$')
+            plt.ylabel(r'$Y$')
+            plt.legend()
+        
+    def plot3d(self,colX=0,colY=1):
+        """ Plot of inputs and predicted data in mesh format
+        Returns:
+            plotly plot
+        """
+        X = self.X
+        self.model.eval()
+        x = X[:,colX].numpy().ravel()
+        y = X[:,colY].numpy().ravel()
+        z = self.model(X).detach().numpy().ravel()
+        surf = px.scatter_3d(x=x, y=y,z=self.df.iloc[:,self.indexes[-1]].values[:self.split_idx],opacity=0.3,
+                             labels={'x':f'{self.column_names[colX]}',
+                                     'y':f'{self.column_names[colY]}',
+                                     'z':f'{self.column_names[-1]}'
+                                     },title='Mesh prediction plot'
+                            )
+        # fig.colorbar(surf, shrink=0.5, aspect=5)
+        surf.update_traces(marker_size=3)
+        surf.update_layout(plot_bgcolor='#888888')
+        surf.add_mesh3d(x=x, y=y, z=z, opacity=0.7,colorscale='sunsetdark',intensity=z,
+            )
+        # surf.show()
+        
+        return surf
+    def performance(self,c=0.4) -> dict:
+        """ Automatic APE based performance if applicable, else returns nan
+        Args:
+             c (float, optional): ZDE mitigation constant. Defaults to 0.4.
+        Returns:
+            dict: {'Generator_Accuracy, %':np.mean(a),'APE_abs, %':abs_ape,'Model_APE, %': ape}
+        """
+        a=[]
+        for i in range(1000):
+            a.append(100-abs(np.mean(self.df.iloc[1:24,1:8].values-self.df.iloc[24:,1:8].sample(23).values)/(self.Y.numpy()[1:]+c))*100)
+        gen_acc = np.mean(a)
+        ape = (100-abs(np.mean(self.model(self.X).detach().numpy()-self.Y.numpy()[1:])*100))
+        abs_ape = ape*gen_acc/100
+        return {'Generator_Accuracy, %':np.mean(a),'APE_abs, %':abs_ape,'Model_APE, %': ape}
+    
+    def performance_super(self,c=0.4,real_data_column_index:tuple = (1,8),real_data_samples:int=23, generated_length:int=1000) -> dict:
+        """Performance by custom parameters. APE loss
+        Args:
+            c (float, optional): ZDE mitigation constant. Defaults to 0.4.
+            real_data_column_index (tuple, optional): Defaults to (1,8).
+            real_data_samples (int, optional): Defaults to 23.
+            generated_length (int, optional): Defaults to 1000.
+        Returns:
+            dict: {'Generator_Accuracy, %':np.mean(a),'APE_abs, %':abs_ape,'Model_APE, %': ape}
+        """
+        a=[]
+        for i in range(1000):
+            a.append(100-abs(np.mean(self.df.iloc[1:real_data_samples+1,real_data_column_index[0]:real_data_column_index[1]].values-self.df.iloc[real_data_samples+1:,real_data_column_index[0]:real_data_column_index[1]].sample(real_data_samples).values)/(self.Y.numpy()[1:]+c))*100)
+        gen_acc = np.mean(a)
+        ape = (100-abs(np.mean(self.model(self.X).detach().numpy()-self.Y.numpy()[1:])*100))
+        abs_ape = ape*gen_acc/100
+        return {'Generator_Accuracy, %':np.mean(a),'APE_abs, %':abs_ape,'Model_APE, %': ape}
+    
+    def performance_super(self,c=0.4,real_data_column_index:tuple = (1,8),real_data_samples:int=23, generated_length:int=1000) -> dict:
+        a=[]
+        for i in range(1000):
+            a.append(100-abs(np.mean(self.df.iloc[1:real_data_samples+1,real_data_column_index[0]:real_data_column_index[1]].values-self.df.iloc[real_data_samples+1:,real_data_column_index[0]:real_data_column_index[1]].sample(real_data_samples).values)/(self.Y.numpy()[1:]+c))*100)
+        gen_acc = np.mean(a)
+        ape = (100-abs(np.mean(self.model(self.X).detach().numpy()-self.Y.numpy()[1:])*100))
+        abs_ape = ape*gen_acc/100
+        return {'Generator_Accuracy, %':np.mean(a),'APE_abs, %':abs_ape,'Model_APE, %': ape}
+    def performance_super(self,c=0.4,real_data_column_index:tuple = (1,8),real_data_samples:int=23, generated_length:int=1000) -> dict:
+        a=[]
+        for i in range(1000):
+            a.append(100-abs(np.mean(self.df.iloc[1:real_data_samples+1,real_data_column_index[0]:real_data_column_index[1]].values-self.df.iloc[real_data_samples+1:,real_data_column_index[0]:real_data_column_index[1]].sample(real_data_samples).values)/(self.Y.numpy()[1:]+c))*100)
+        gen_acc = np.mean(a)
+        ape = (100-abs(np.mean(self.model(self.X).detach().numpy()-self.Y.numpy()[1:])*100))
+        abs_ape = ape*gen_acc/100
+        return {'Generator_Accuracy, %':np.mean(a),'APE_abs, %':abs_ape,'Model_APE, %': ape}
+    
+class RCI(SCI): #Real object interface
+    """ Real values interface, uses different types of NN, NO scaling.
+    Parent:
+        SCI()
+    """
+    def __init__(self,*args,**kwargs):
+        super(RCI,self).__init__()
+        
+    def data_flow(self,columns_idx:tuple = (1,3,3,5), idx:tuple=None, split_idx:int = 800) -> torch.utils.data.DataLoader:
+            """ Data prep pipeline
+            Args:
+                columns_idx (tuple, optional): Columns to be selected (sliced 1:2 3:4) for feature fitting. Defaults to (1,3,3,5). 
+                idx (tuple, optional): 2|3 indexes to be selected for feature fitting. Defaults to None. Use either idx or columns_idx (for F:R->R idx, for F:R->R2 columns_idx)
+                split_idx (int) : Index to split for training
+                
+            Returns:
+                torch.utils.data.DataLoader: Torch native dataloader
+            """
+            batch_size=2
+            
+            real_scale = pd.read_csv('data/dataset.csv').iloc[17,1:].to_numpy()
+            self.df.iloc[:,1:] = self.df.iloc[:,1:] * real_scale
+            
+            self.split_idx=split_idx
+            
+                        
+            if idx!=None:
+                self.len_idx = len(idx)
+                if len(idx)==2:
+                    self.X = tensor(self.df.iloc[:,idx[0]].values[:split_idx].astype(float)).float()
+                    self.Y = tensor(self.df.iloc[:,idx[1]].values[:split_idx].astype(float)).float()
+                    batch_size = 1
+                else:
+                    self.X = tensor(self.df.iloc[:,[idx[0],idx[1]]].values[:split_idx,:].astype(float)).float()
+                    self.Y = tensor(self.df.iloc[:,idx[2]].values[:split_idx].astype(float)).float()
+            else:
+                self.X = tensor(self.df.iloc[:,columns_idx[0]:columns_idx[1]].values[:split_idx,:].astype(float)).float()
+                self.Y = tensor(self.df.iloc[:,columns_idx[2]:columns_idx[3]].values[:split_idx].astype(float)).float()
+            self.Y = self.Y.abs()
+            self.X = self.X.abs()
+            
+            print('Shapes for debug: (X,Y)',self.X.shape, self.Y.shape)
+            train_data = torch.utils.data.TensorDataset(self.X, self.Y)
+            Xtrain = torch.utils.data.DataLoader(train_data,batch_size=batch_size)
+            self.input_dim = self.X.size(-1)
+            self.indexes = idx if idx else columns_idx
+            self.column_names = [ self.df.columns[i] for i in self.indexes ]
+            
+            
+            
+            
+            return Xtrain
+        
+    def compile(self,columns:tuple=None,idx:tuple=(3,1), optim:torch.optim = torch.optim.AdamW,loss:nn=nn.L1Loss, model:nn.Module = PINNd_p,lr:float=0.001) -> None:
+        """ Builds model, loss, optimizer. Has defaults
+        Args:
+            columns (tuple, optional): Columns to be selected for feature fitting. Defaults to None.
+            idx (tuple, optional): indexes to be selected Default (3,1)
+            optim - torch Optimizer
+            loss - torch Loss function (nn)
+        """
+        
+        self.columns = columns
+        
+                
+        if not(columns):
+            self.len_idx = 0
+        else:
+            self.len_idx = len(columns)
+            
+        if not(self.columns) and not(idx):
+            self.Xtrain = self.data_flow()
+        elif not(idx): 
+            self.Xtrain = self.data_flow(columns_idx=self.columns)
+        else:
+            self.Xtrain = self.data_flow(idx=idx)
+        
+        self.model = model().float()
+        self.input_dim_for_check = self.X.size(-1)
+                
+        self.optim = optim(self.model.parameters(), lr=lr)
+        self.loss_function = loss()
+            
+        if self.input_dim_for_check == 1:
+            self.X  = self.X.reshape(-1,1)
+    def plot(self):
+        """ Plots 2d plot of prediction vs real values
+        """
+        self.model.eval()
+        if 'PINN' in str(self.model.__class__):
+            self.preds=np.array([])
+            for i in self.X:
+                self.preds = np.append(self.preds,self.model(i).detach().numpy()) 
+        print(self.Y.shape,self.preds.shape,self.X.shape)
+        if self.X.shape[-1] != self.preds.shape[-1]:
+            print('Size mismatch, try 3d plot, plotting by first dim of largest tensor')
+            try: X = self.X[:,0]
+            except:
+                X = self.X
+                pass
+            plt.scatter(X,self.preds,label='predicted',s=2)
+            if self.Y.shape[-1]!=1:
+                sns.scatterplot(x=X,y=self.Y,s=2,label='real')
+            else:
+                sns.scatterplot(x=X,y=self.Y,s=1,label='real')
+            plt.xlabel(rf'${self.column_names[0]}$')
+            plt.ylabel(rf'${self.column_names[1]}$')
+            plt.legend()
+        else:
+            sns.scatterplot(x=self.X,y=self.preds,s=2,label='predicted')
+            sns.scatterplot(x=self.X,y=self.Y,s=1,label='real')
+            plt.xlabel(r'$X$')
+            plt.ylabel(r'$Y$')
+            plt.legend()
+            
+    def performance(self,c=0.4) -> dict:
+        """RCI performnace. APE errors.
+        Args:
+            c (float, optional): correction constant to mitigate division by 0 error. Defaults to 0.4.
+        Returns:
+            dict: {'Generator_Accuracy, %':np.mean(a),'APE_abs, %':abs_ape,'Model_APE, %': ape}
+        """
+        a=[]
+        for i in range(1000):
+            dfcopy = (self.df.iloc[:,1:8]-self.df.iloc[:,1:8].min())/(self.df.iloc[:,1:8].max()-self.df.iloc[:,1:8].min())
+            a.append(100-abs(np.mean(dfcopy.iloc[1:24,1:].values-dfcopy.iloc[24:,1:].sample(23).values)/(dfcopy.iloc[1:24,1:].values+c))*100)
+        gen_acc = np.mean(a)
+        
+        ape = (100-abs(np.mean(self.preds-self.Y.numpy())*100))
+        abs_ape = ape*gen_acc/100
+        return {'Generator_Accuracy, %':np.mean(a),'APE_abs, %':abs_ape,'Model_APE, %': ape}
+    
+            
+