ПАЙТОН БОДЛОГО №1 (Сорьцлолтын төлөөлөх дээжний хамгийн бага жин)

Энэхүү python программ нь GY-ийн томьёогоор төлөөлөх дээжний хамгийн бага жинг олно.

#  Gy-ийн томьёоны Python функц
# Author: G. Davaatseren - Python for Mineral Processing Engineers

def gy_min_sample_mass(C: float, d_mm: float, rho: float, f: float) -> float:
     # мм-ийг метр болгох
    d_m = d_mm / 1000.0
    
    # Gy-ийн томьёо
    m_tonnes = (C * (d_m ** 3) * rho) / (f ** 2)
    return m_tonnes
    
#  Жишээ бодлогын өгөгдөл

C = 0.5      # Gy constant
d_mm = 50.0  # top size, мм
rho = 2.7    # t/m3
f = 0.05     # 5% relative error

m_min_t = gy_min_sample_mass(C, d_mm, rho, f)
m_min_kg = m_min_t * 1000  # кг руу хөрвүүлэх

print(f"Хамгийн бага сорьцын масс ≈ {m_min_t:.4f} тн")
print(f"Эсвэл ≈ {m_min_kg:.1f} кг")

#  Ялгаатай ширхэглэл (d) болон алдааны түвшин (f) -ийн нөлөөг харуулах

import numpy as np
import matplotlib.pyplot as plt

C = 0.5
rho = 2.7

# 20 мм-ээс 100 мм хүртэл
d_values = np.linspace(20, 100, 9)  # 20, 30, ..., 100 мм
f_values = [0.1, 0.05, 0.03]        # 10%, 5%, 3%

plt.figure(figsize=(7,5))

for f in f_values:
    m_list = []
    for d_mm in d_values:
        m_list.append(gy_min_sample_mass(C, d_mm, rho, f) * 1000)  # кг
    plt.plot(d_values, m_list, marker="o", label=f"f = {f*100:.0f} %")

plt.xlabel("Хамгийн том ширхэглэл, d (мм)")
plt.ylabel("Хамгийн бага сорьцын масс, m (кг)")
plt.title("Gy-ийн томьёогоор   өөрчлөгдөхөд сорьцын масс")
plt.grid(True)
plt.legend()
plt.show()

Линч - Витены бутлалтын загвар (Lynch - Whiten)

Энэхүү python программ нь 1977 онд Линчийн боловсруулсан матрицын аргаар бутлалтын циклыг загварчлалыг гүйцэтгэнэ.

# ---------- Fresh feed ----------
Q_fresh = 1812.0      # tph
F80_feed_mm = 45.0    # for information

# Example feed PSD (replace with real data!)
feed_psd = np.array([0.02, 0.04, 0.09, 0.20, 0.30, 0.35], dtype=float)
feed_psd /= feed_psd.sum()

print("Check feed P80 (mm):", calc_P80(feed_psd))

def build_breakage_matrix(size_mid):
    """
    Simple lower-triangular Whiten-style breakage matrix.
    You can calibrate this later from testwork.
    """
    n = len(size_mid)
    B = np.zeros((n, n))
    for i in range(n):
        B[i, i] = 0.4
        if i >= 1:
            B[i, i-1] += 0.3
        if i >= 2:
            B[i, i-2] += 0.2
        if i >= 3:
            B[i, i-3] += 0.1
        B[i] /= B[i].sum()
    return B
def build_classification_matrix(size_mid, css_mm=18.0):
    """
    Lynch selection function (probability of breakage).
    """
    n = len(size_mid)
    C = np.zeros((n, n))
    for i, d in enumerate(size_mid):
        if d > 2.5 * css_mm:
            pb = 0.95
        elif d > css_mm:
            pb = 0.70
        elif d > 0.5 * css_mm:
            pb = 0.40
        else:
            pb = 0.05
        C[i, i] = pb
    return C

B = build_breakage_matrix(size_mid)
C = build_classification_matrix(size_mid, css_mm=18.0)  # guess CSS

def cone_crusher(feed_psd, B, C):
    """
    Whiten cone crusher:
        P = F (I - C) + F C B
    """
    F = feed_psd.reshape(1, -1)
    I = np.eye(len(feed_psd))
    P = F @ (I - C) + F @ C @ B
    P = P.ravel()
    P = np.maximum(P, 0)
    P /= P.sum()
    return P

def build_partition_curve(size_mid, d50=14.0, sharpness=2.0):
    """
    Partition curve: probability to undersize.
      p_u(d) = 1 / (1 + (d/d50)^sharpness)
    """
    d = size_mid
    return 1.0 / (1.0 + (d / d50) ** sharpness)

p_u = build_partition_curve(size_mid, d50=14.0, sharpness=2.0)

def screen_step(feed_mass_by_class, p_u):
    """
    feed_mass_by_class: tph per size class
    """
    mass_U = feed_mass_by_class * p_u
    mass_O = feed_mass_by_class - mass_U

    Q_U = mass_U.sum()
    Q_O = mass_O.sum()

    psd_U = mass_U / Q_U if Q_U > 0 else np.zeros_like(mass_U)
    psd_O = mass_O / Q_O if Q_O > 0 else np.zeros_like(mass_O)

    return mass_U, mass_O, Q_U, Q_O, psd_U, psd_O
    def simulate_circuit(Q_fresh, feed_psd, B, C, p_u,
                     max_iter=1000, tol=1e-4):
    n = len(feed_psd)

    Q_recycle = 0.0
    psd_recycle = np.zeros(n)

    for it in range(max_iter):
        Q_cr_feed = Q_fresh + Q_recycle

        if Q_cr_feed > 0:
            psd_cr_feed = (Q_fresh * feed_psd + Q_recycle * psd_recycle) / Q_cr_feed
        else:
            psd_cr_feed = feed_psd.copy()

        psd_cr_prod = cone_crusher(psd_cr_feed, B, C)

        mass_screen_feed = Q_cr_feed * psd_cr_prod
        (mass_U, mass_O,
         Q_U, Q_O,
         psd_U, psd_O) = screen_step(mass_screen_feed, p_u)

        # screen feed PSD for plotting
        psd_screen_feed = mass_screen_feed / mass_screen_feed.sum()

        Q_recycle_new = Q_O
        psd_recycle_new = psd_O.copy()

        rel_change = abs(Q_recycle_new - Q_recycle) / max(Q_cr_feed, 1e-6)
        Q_recycle, psd_recycle = Q_recycle_new, psd_recycle_new

        if rel_change < tol:
            print(f"Converged in {it+1} iterations.")
            break

    results = {
        # rates
        "Q_fresh": Q_fresh,
        "Q_crusher_feed": Q_cr_feed,
        "Q_recycle": Q_recycle,
        "Q_product": Q_U,
        # PSDs
        "psd_fresh": feed_psd,
        "psd_crusher_feed": psd_cr_feed,
        "psd_crusher_product": psd_cr_prod,
        "psd_screen_feed": psd_screen_feed,
        "psd_screen_oversize": psd_O,
        "psd_screen_undersize": psd_U,
    }
    return results
    
    res = simulate_circuit(Q_fresh, feed_psd, B, C, p_u)

Q_prod = res["Q_product"]
P80_prod = calc_P80(res["psd_screen_undersize"])

print("\n=== Steady-state summary ===")
print(f"Fresh feed rate          : {res['Q_fresh']:.1f} tph")
print(f"Crusher feed rate        : {res['Q_crusher_feed']:.1f} tph")
print(f"Recycle (screen oversize): {res['Q_recycle']:.1f} tph")
print(f"Final product rate       : {Q_prod:.1f} tph")
print(f"Final product P80 (mm)   : {P80_prod:.2f} mm")
    

МАШИН СУРГАЛТЫН (ХИЙМЭЛ ОЮУНЫ) ЭНГИЙН PYTHON ПРОГРАММ

===========================================================================================================================
Энэхүү программ нь Python-ы Tensorflow , Keras зэрэг сангуудыг ашиглан машин сургалтын аргаар (хиймэл оюун) ажилд орохыг
хүссэн өргөдлүүдийг хиймэл оюуны тусламжтайгаар шийдвэр гаргах юм. 
 Иймэрхүү байдлаар тэндэр дүгнэж шийдвэр гаргах, Баяжуулах үйлдвэрийн олон хүчин зүйлүүдийг боловсруулж өмнө нь мэдэгдээгүй
хууль зүйг нээн илрүүлэх зэрэгт амжилттаөй хэрэглэж болох юм.

Өргөдлийн өгөгдлүүд:
- Ажлын туршлага , жилээр
- Ажлын туршлагын оноо (0-100)
- Ярианы чадвар 
- Боловсролын түвшин

Шийдвэр:
0 - ажилд авахгүй
1- ажилд авна

==========================================================================================================================
import numpy a
import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt

# 1. ӨГӨГДӨЛ БЭЛДЭХ
# Оролтын өгөгдөл: [туршлага(жил), оноо(100-аас), ярианы чадвар(0-1), боловсролын түвшин(0-2)]
# Гаралт: 0 - ажилд авахгүй, 1 - ажилд авна

# Сургалтын өгөгдөл

X_train = np.array([
    [2, 65, 0.3, 1],   # анхны өргөдөл
    [5, 80, 0.7, 2],   # хоёр дахь өргөдөл
    [1, 45, 0.2, 0],   # гэх мэт...
    [8, 90, 0.9, 2],
    [3, 70, 0.5, 1],
    [0, 35, 0.1, 0],
    [10, 95, 0.95, 2],
    [4, 75, 0.6, 1]
])

# Харгалзах хариу (мэргэжилтний шийдвэр)
y_train = np.array([0, 1, 0, 1, 1, 0, 1, 1])

# 2. НЕЙРОН СҮЛЖЭЭГ БҮТЭЭХ
model = keras.Sequential([
    keras.layers.Dense(8, activation='relu', input_shape=(4,)),  # Далд давхарга
    keras.layers.Dense(4, activation='relu'),                   # Давхарга нэмэх
    keras.layers.Dense(1, activation='sigmoid')                 # Гаралтын давхарга
])

# 3. СҮЛЖЭЭГ ТОХИРУУЛАХ
model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy']
)

# 4. СУРГАЛТ ХИЙХ
print("Сургалт эхлэж байна...")
history = model.fit(
    X_train, 
    y_train,
    epochs=100,
    batch_size=2,
    verbose=0  # Дэлгэцэд хэт олон мэдээлэл харуулахгүй
)

# 5. ШИНЭ ӨГӨГДӨЛ ДЭЭР ТААМАГЛАЛ ХИЙХ
# Шинэ өргөдөл: [туршлага, оноо, ярианы чадвар, боловсрол]
new_applicants = np.array([
    [3, 72, 0.6, 1],   # 1-р өргөдөл
    [6, 85, 0.8, 2],   # 2-р өргөдөл  
    [1, 40, 0.1, 0]    # 3-р өргөдөл
])

predictions = model.predict(new_applicants)

# 6. ҮР ДҮНГ ХАРУУЛАХ
print("\n" + "="*50)
print("ШИНЭ ӨРГӨДӨЛҮҮДИЙН ШИЙДВЭР:")
print("="*50)

for i, (applicant, pred) in enumerate(zip(new_applicants, predictions)):
    probability = pred[0]
    decision = "АЖИЛД АВАХ" if probability > 0.5 else "АЖИЛД АВАХГҮЙ"
    
    print(f"\n{i+1}-р өргөдөл:")
    print(f"  Туршлага: {applicant[0]} жил")
    print(f"  Оноо: {applicant[1]}/100")
    print(f"  Ярианы чадвар: {applicant[2]:.1%}")
    print(f"  Боловсрол: {['Бага', 'Дунд', 'Дээд'][int(applicant[3])]}")
    print(f"  Магадлал: {probability:.2%}")
    print(f"  ШИЙДВЭР: {decision}")

# 7. СУРГАЛТЫН ТҮҮХИЙГ ХАРУУЛАХ
plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.plot(history.history['loss'])
plt.title('Сургалтын алдаа')
plt.xlabel('Эпох')
plt.ylabel('Алдаа')

plt.subplot(1, 2, 2)
plt.plot(history.history['accuracy'])
plt.title('Сургалтын нарийвчлал')
plt.xlabel('Эпох')
plt.ylabel('Нарийвчлал')

plt.tight_layout()
plt.show()

# 8. ЗАГВАРЫН ДЭЛГЭРЭНГҮЙ МЭДЭЭЛЭЛ
print("\n" + "="*50)
print("ЗАГВАРЫН ДЭЛГЭРЭНГҮЙ МЭДЭЭЛЭЛ:")
print("="*50)
model.summary()