Physics Fusion Guess – Could The Same Ion Exist At Different Locations In The Plasma At The Same Time?

Like carpentry when two people is helping each other. What to do when there is no one around. If the electron can exist at different locations in the same time. That could have been due to some function that is very much needed.

So when building new material, ?fusion. That function is probably needed.

From this I guess that the same ion in plasma can exist at different locations at the same time.

Living Environment Idea – Education About Garbage? Perhaps Its The Most Important Idea On How To Clean Up The Planet

Inspired by machine learning. What about having a Recycle Number Circle like a label on each purchable item. This way you don’t have to make a decision. Which item belongs to which bin.

Just have each number with 10,20,30,40,50 for glass, paper, plastic, … then its possible with some more selection like green or clear glass for 10,11.

Super Image Compression – Adapt The model(rnge()) With np.sort(Weight Matrices). This Way You Can Compress The Sorted Weight Matrices Using Another Algorithm

So the idea is to iterate and adapt the model() to fit an image. To make the whole system smaller. Insert np.sort() for the model weights. This way you can ?lossy compress the weight matrix and get a smaller overall file. Since a many sorted data under some denoising does look continous.

Python Idea – Simple Exercises From Images

A beginner python exercise. Fill in the missing line.


Machine Learning – Key Idea – Iteration With model(rnge()) Where rnge() Is A Sorted List Of Numbers

When I want to solve something with machine learning. Like the Three Body Problem or something like that. I use a model( rnge() ) where

def rnge():
return 1e-5*np.linspace(0,1,100).reshape(1,100).astype(np.float32)

So the idea is that the model adapts with the ?whole number line as input. Or at least a part of it. So here I scaled it down so that the model() would have time to adapt

My model() does not need to be very deep or many units for iterations to work. Just

class Model(chainer.Chain):
def __init__(self, n_hidden,n_out):
super(Model, self).__init__()
with self.init_scope():
self.l1 = L.Linear(None, n_hidden)
self.l2 = L.Linear(None, n_hidden*2)
self.l3 = L.Linear(None, n_out)
def __call__(self, x):
x = F.relu(self.l1(x))
x = -F.relu(self.l2(-x))
x = self.l3(x)
return x

#end of class description

hidden = 15
model00 = Model(hidden,1)
optimizer00 = chainer.optimizers.Adam()

Then in the loop you just add a = model(rnge()) and some loss = F.mean_square_error( 0 , eq(a) ). That is. Your equation that needs to be solved and then loss.backward() and then update the model with the optimizer.update().

Machine Element Innovation – Spinning Vibration Elongation(x,y,z,t) Absorbing Rock Layer

The idea is simple.

Looking at the road. I think there is a rock layer underneath. For vibration and engineering purposes. So from this. What other inventions could use rocks as a machine element.

What if you could increase performance of big electrical motors with a layer of ?small rocks. So when it rotates. I guess the stresses elongate the motor parts differently and there I think you can have a new machine element. The rock layer.

Physical Unknowns Have A Loss Function? – Why Is The Color Red, Red?

What if the reason for the color red is itself an in-data for a model?

So you have model(generator(“reasons for red”)). That is. Of all questions this generator could make the color should be red.

Then the model() is then responsible for ?the universe red-loss equation.

So there exist a reason for red. An ?unknown loss function generated from a ?lot of reasons. One such reason could be that it makes it easier for life.

Machine Learning Physics Speculation – Newtons Law Of Gravity Is ?Never Singular Using F*r**2 = G*m1*m2. Here F = modelF() and G = modelG(). Both Iterates Like A Loss Function // Per Lindholm

Just a quick speculation.

If you use AI.Thesaurus thinking . Then gravity is close to minimization of distances. So at each iteration you got some force to physically bringing objects closer to each other.

Bringing things closer in machine learning terms means getting a lower loss. So to solve this simple equation I assume a modelF() for F and different modelG() for G. Then since a machine learning model can assume any function their complex behaviour could solve this equation at any distance r.

Basically you got F.mean_squared_error(modelF()*r**2, modelG()*m1*m2). That is G ?is some dynamically update possible constant.

So the idea is that both modelF and modelG will start to work together to solve the equation or loss function.