什么是电子？论文如何写是硕士博士生最头痛的工作之一，这些小推文或许会有所启示。
现代物理化学理论中称的电子具有特定的概念，是指一种较小质量的粒子，人们将带有一个最小电量单位的电荷称为电子，认为一个电子带一个单位的负电荷，一个质子带一个单位的正电荷，认为质子与电子所带的电荷是相等的。实际上所有物质都是共轭的，即每一种粒子都有各自的反粒子，由于历史上没有确切的带正电荷的正电子概念，所以1930年狄拉克根据推导提出了空穴理论，所谓空穴是必然存在一种与带一个单位的负电荷的电子相匹配的正电荷的位置，才能保证真空概念的存在，从词义上理解，空穴是不会动的，是负电子去填补正电荷的位置上的空穴，这是因为当时根深蒂固地认为“电子是带负电荷的最小粒子，质子是带正电荷的最小粒子”的观点固化，所以尽管狄拉克推导出存在带正电荷的电子存在，因此引入空穴，供带负电荷的电子复合。所以严格意义上来说空穴与正电子等效，但概念上不是正电子，因电子质量小会发生移动，而空穴不会移动，只是可填充的位置。实际上正电子后来被发现，也有明确的正电子概念，但人们认为正电子在物质世界上存在很少，同样认为带负电荷的质子也很少，显然此观点又与所有粒子都有各自的共轭的反物质相矛盾，既然是共轭，“都”具有各自的反粒子相矛盾，既然是共轭，就应当不仅所带电荷相反，而且在质量上、数量上都应当相等，可见科学家们一直未能走出此误区。
人们一直停留在一个一个地发现粒子，从基本粒子的提出到除去基本限制性词，不断地发现更多的粒子，实际上，无论是哲学还是中国更早的八卦理论，物质可无限分取，所以物质世界的粒子是无限多、无限小的，同理更大的粒子是由更小的粒子凝聚而成。而物质的凝聚是由阴阳电荷的相互作用而发生的。
在足够小的粒子体积上，根据能量最低原理，每个足够小的微粒子最多能带一个单位的正电荷或负电荷，要么不显电性，因此每个足够小的电子、光子、质子、中子、夸克最多带一个单位的电荷e。也就是正负光子、正负电子、正负质子、正负中子、正负夸克所带的电荷量都是1.6×10-19C，因此由于带电粒子在磁场中受到的洛仑兹力作用力总是与电荷的运动方向垂直并且所受力的大小只与电荷有关，因此观察Fig.75云室中显示的带等量电荷e的带电粒子受到同样大小的洛仑兹力时，质量大的只是略有偏转，如中间偏转很小的、几乎作直线运动可以确定为质子类轨迹，根据偏转程度可以确定共轭E-E'、F-F'是质量略有不同的两类质子，偏转旋转方向相反，说明是带相反电荷的共轭的正负质子。而那些共轭的涡旋轨迹半径显著不同，有的大有的小，无论涡旋大小，都没有显著的直线运动的迹象，根据牛顿惯性定律，可以得出这些粒子的质量大小显著不同，可以认为偏转极小的中间部分的射线为正负质子、中子射线，于是把这些涡旋运动的带一个单位电荷的粒子划规为电子类，如A-A'、B-B'、C-C'、D-D'，带电粒子在磁场中受到洛仑兹力作用时偏转程度显著不同，说明即使都是电子，而这些电子并非为全同粒子，即不是所有的电子都是相同的，这些电子所凝聚成的质子、中子也不同，所有可以得出结论所有的质子并非全同粒子，中子也如此，因此导致原子核出更质量亏损现象的原因于此，也正因如此才导致有各样的元素和物质世界。之所以根据云室图中的轨迹判断这些粒子分别为质子、中子和电子，是因为在自然界中物质衰变时释放出的最小粒子除了电子、质子、中子符合科学家给出的这类粒子的概念，此外更大的原子、分子之类，以及更小的是光子、引力子、电场子、磁场子都与之不符合。
电子非常容易获取，吹一口气都是巨量的正负电子，随手一挥也产生巨量的正负电子气体，电子气体是能量的一种形式，空中的云、风、洋流都充满各种带电粒子。

refer to the following Colab python code,
write a new Colab python code for request :
user import Three View or Multiview orthographic projection image png jpg etc file, loading image to produce 3D cloud point,
write the results on .obj file

! pip install plotly -q

!git clone https://t.cn/A6KTcqVE

%cd shap-e
!pip install -e .

!git clone https://t.cn/A6NRWmuS

#Enter the directory and install the requirements
%cd shap-e
!pip install -e .

from PIL import Image
import torch
from tqdm.auto import tqdm

from point_e.diffusion.configs import DIFFUSION_CONFIGS, diffusion_from_config
from point_e.diffusion.sampler import PointCloudSampler
from point_e.models.download import load_checkpoint
from point_e.models.configs import MODEL_CONFIGS, model_from_config
from point_e.util.plotting import plot_point_cloud

#Implementation and Cooking the 3D models, import all the necessary libraries.
#%cd /content/shap-e
import torch

from shap_e.diffusion.sample import sample_latents
from shap_e.diffusion.gaussian_diffusion import diffusion_from_config
from shap_e.models.download import load_model, load_config
from shap_e.util.notebooks import create_pan_cameras, decode_latent_images, gif_widget

#set the device to cuda if available, otherwise to cpu.
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

#load the models and weights.
xm = load_model('transmitter', device=device)
model = load_model('text300M', device=device)
diffusion = diffusion_from_config(load_config('diffusion'))

#generate the 3D models.
batch_size = 1 # this is the size of the models, higher values take longer to generate.
guidance_scale = 65.0 # this is the scale of the guidance, higher values make the model look more like the prompt.

latents = sample_latents(

batch_size=batch_size,

model=model,

diffusion=diffusion,

guidance_scale=guidance_scale,

model_kwargs=dict(texts=[prompt] * batch_size),

progress=True,

clip_denoised=True,

use_fp16=True,

use_karras=True,

karras_steps=64,

sigma_min=1E-3,

sigma_max=160,

s_churn=0,
)

render_mode = 'stf' #
size = 128 # this is the size of the renders, higher values take longer to render.

cameras = create_pan_cameras(size, device)
for i, latent in enumerate(latents):

images = decode_latent_images(xm, latent, cameras, rendering_mode=render_mode)

display(gif_widget(images))

#save the 3D models as .ply and .obj files.
# Example of saving the latents as meshes.
from shap_e.util.notebooks import decode_latent_mesh

for i, latent in enumerate(latents):

t = decode_latent_mesh(xm, latent).tri_mesh()

with open(f'example_mesh_{i}.ply', 'wb') as f: # this is three-dimensional geometric data of model.

t.write_ply(f)

with open(f'example_mesh_{i}.obj', 'w') as f: # we will use this file to customize in Blender Studio later.

t.write_obj(f)

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

print('creating base model...')
base_name = 'base40M'
base_model = model_from_config(MODEL_CONFIGS[base_name], device)
base_model.eval()
base_diffusion = diffusion_from_config(DIFFUSION_CONFIGS[base_name])

print('creating upsample model...')
upsampler_model = model_from_config(MODEL_CONFIGS['upsample'], device)
upsampler_model.eval()
upsampler_diffusion = diffusion_from_config(DIFFUSION_CONFIGS['upsample'])

print('downloading base checkpoint...')
base_model.load_state_dict(load_checkpoint(base_name, device))

print('downloading upsampler checkpoint...')
upsampler_model.load_state_dict(load_checkpoint('upsample', device))

sampler = PointCloudSampler(

device=device,

models=[base_model, upsampler_model],

diffusions=[base_diffusion, upsampler_diffusion],

num_points=[1024, 4096 - 1024],

aux_channels=['R', 'G', 'B'],

guidance_scale=[3.0, 3.0],
)

from google.colab import files
uploaded = files.upload()

# Load an image to condition on.
img = Image.open('figure_all.jpg')

# Produce a sample from the model.
samples = None
for x in tqdm(sampler.sample_batch_progressive(batch_size=1, model_kwargs=dict(images=[img]))):

samples = x

img

pc = sampler.output_to_point_clouds(samples)[0]

fig = plot_point_cloud(pc, grid_size=3, fixed_bounds=((-0.75, -0.75, -0.75),(0.75, 0.75, 0.75)))

import plotly.graph_objects as go

fig_plotly = go.Figure(

data=[

go.Scatter3d(

x=pc.coords[:,0], y=pc.coords[:,1], z=pc.coords[:,2],

mode='markers',

marker=dict(

size=2,

color=['rgb({},{},{})'.format(r,g,b) for r,g,b in zip(pc.channels["R"], pc.channels["G"], pc.channels["B"])],

)

)

],

layout=dict(

scene=dict(

xaxis=dict(visible=False),

yaxis=dict(visible=False),

zaxis=dict(visible=False)

)

),

)

fig_plotly.show(renderer="colab")

from point_e.util.pc_to_mesh import marching_cubes_mesh

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

print('creating SDF model...')
name = 'sdf'
model = model_from_config(MODEL_CONFIGS[name], device)
model.eval()

print('loading SDF model...')
model.load_state_dict(load_checkpoint(name, device))

import skimage.measure as measure

# Produce a mesh (with vertex colors)
mesh = marching_cubes_mesh(

pc=pc,

model=model,

batch_size=4096,

grid_size=32, # increase to 128 for resolution used in evals

progress=True,
)

# Write the mesh to a PLY file to import into some other program.
with open('figure_all.obj', 'wb') as f:

mesh.write_ply(f)

import requests
from PIL import Image
import torch
from tqdm.auto import tqdm
from shap_e.diffusion.sample import sample_latents
from shap_e.diffusion.gaussian_diffusion import diffusion_from_config
from shap_e.models.download import load_model, load_config
from shap_e.util.notebooks import create_pan_cameras, decode_latent_images, gif_widget
from shap_e.util.notebooks import decode_latent_mesh
from shap_e.util.pc_to_mesh import marching_cubes_mesh

# Install necessary packages
!pip install plotly -q

# Clone the required repositories
!git clone https://t.cn/A6KTcqVE
%cd point-e
!pip install -e .
%cd ..

!git clone https://t.cn/A6NRWmuS
%cd shap-e
!pip install -e .
%cd ..

def generate_3d_model(image_path, prompt, render_mode='stf', size=128):

# Load models and weights

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

xm = load_model('transmitter', device=device)

model = load_model('text300M', device=device)

diffusion = diffusion_from_config(load_config('diffusion'))

# Generate 3D models

batch_size = 1

guidance_scale = 65.0

latents = sample_latents(

batch_size=batch_size,

model=model,

diffusion=diffusion,

guidance_scale=guidance_scale,

model_kwargs=dict(texts=[prompt] * batch_size),

progress=True,

clip_denoised=True,

use_fp16=True,

use_karras=True,

karras_steps=64,

sigma_min=1E-3,

sigma_max=160,

s_churn=0,

)

cameras = create_pan_cameras(size, device)

for i, latent in enumerate(latents):

images = decode_latent_images(xm, latent, cameras, rendering_mode=render_mode)

display(gif_widget(images))

# Save the 3D models as .ply and .obj files

for i, latent in enumerate(latents):

t = decode_latent_mesh(xm, latent).tri_mesh()

with open(f'example_mesh_{i}.ply', 'wb') as f:

t.write_ply(f)

with open(f'example_mesh_{i}.obj', 'w') as f:

t.write_obj(f)

# Load the image to condition on

img = Image.open(image_path)

# Produce a sample from the model

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

print('creating base model...')

base_name = 'base40M'

base_model = model_from_config(MODEL_CONFIGS[base_name], device)

base_model.eval()

base_diffusion = diffusion_from_config(DIFFUSION_CONFIGS[base_name])

print('creating upsample model...')

upsampler_model = model_from_config(MODEL_CONFIGS['upsample'], device)

upsampler_model.eval()

upsampler_diffusion = diffusion_from_config(DIFFUSION_CONFIGS['upsample'])

print('downloading base checkpoint...')

base_model.load_state_dict(load_checkpoint(base_name, device))

print('downloading upsampler checkpoint...')

upsampler_model.load_state_dict(load_checkpoint('upsample', device))

sampler = PointCloudSampler(

device=device,

models=[base_model, upsampler_model],

diffusions=[base_diffusion, upsampler_diffusion],

num_points=[1024, 4096 - 1024],

aux_channels=['R', 'G', 'B'],

guidance_scale=[3.0, 3.0],

)

# Load the image to condition on

img = Image.open(image_path)

# Produce a sample from the model

samples = None

for x in tqdm(sampler.sample_batch_progressive(batch_size=1, model_kwargs=dict(images=[img]))):

samples = x

# Convert the output to point clouds

pc = sampler.output_to_point_clouds(samples)[0]

# Plot the point cloud

fig = plot_point_cloud(pc, grid_size=3, fixed_bounds=((-0.75, -0.75, -0.75),(0.75, 0.75, 0.75)))

fig.show(renderer="colab")

# Generate the mesh

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

print('creating SDF model...')

name = 'sdf'

model = model_from_config(MODEL_CONFIGS[name], device)

model.eval()

print('loading SDF model...')

model.load_state_dict(load_checkpoint(name, device))

# Produce a mesh (with vertex colors)

mesh = marching_cubes_mesh(

pc=pc,

model=model,

batch_size=4096,

grid_size=32,

progress=True,

)

# Write the mesh to a PLY file

with open('output.obj', 'wb') as f:

mesh.write_obj(f)

# Example usage
image_path = 'path/to/image.jpg'
prompt = 'example prompt'
generate_3d_model(image_path, prompt)