实用！7个强大的Python机器学习库！⛵

# Python
forecast = m.predict(future)
forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail()

for epoch in range(2):
    running_loss = 0.0
    for i, data in enumerate(deeplake_loader):
    images, labels = data['images'], data['labels']

    # zero the parameter gradients
    optimizer.zero_grad()

    # forward + backward + optimize
    outputs = net(images)
    loss = criterion(outputs, labels.reshape(-1))
    loss.backward()
    optimizer.step()

    # print statistics
    running_loss += loss.item()
    if i % 100 == 99: #print every 100 mini-batches
        print('[%d, %5d] loss: %.3f' %
        (epoch + 1, i + 1, running_loss / 100))
        running_loss = 0.0

import ...

# Define an objective function to be minimized.
def objective(trial):

    # Invoke suggest methods of a Trial object to generate hyperparameters

    regressor_name = trial.suggest_categorical('regressor',['SVR', 'RandomForest'])
    if regressor_name = 'SVR':
        svr_c = trial.suggest_float('svr_c', 1e-10, 1e10, log=True)
        regressor_obj = sklearn.svm.SVR(C=svr_c)
    else:
        rf_max_depth = trial.suggest_int('rf_max_depth', 2, 332)
        regressor_obj = sklearn.ensemble.RandomForestRegressor(max_depth=rf_max_depth)

    X, y = sklearn.datasets.fetch_california_housing(return_X_y=True)
    X_train, X_val, y_train, y_val = sklearn.model_selection.train_test_split(X, y, random_state=0)

    regressor_obj.fit(X_train, y_train) y_pred = regressor_obj.predict(X_val)

    error = sklearn.metrics.mean_squared_error(y_val, y_pred)

    return error # An objective value linked with the Trial object.

study = optuna.create_study() # Create a neW study
study.optimize(objective, n_trials=100) # Invoke opotimization of the objective function

from pycm import *
y_actu = [2, 0, 2, 2, 0, 1, 1, 2, 2, 0, 1, 2] 
y_pred = [0, 0, 2, 1, 0, 2, 1, 0, 2, 2, 2, 2]

cm = ConfusionMatrix(actual_vector=y_actu, predict_vector=y_pred)

cm.classes

cm.print_matrix() 

cm.print_normalized_matrix()

import nannyml as nml
from IPython.display import display

# Load synthetic data

reference, analysis, analysis_target = nml.load_synthnetic_binary_classification_dataset()
display(reference.head())
display(analysis.head())

# Choose a chunker or set a chunk size
chunk size = 5000

# initialize, specify required data columns,, fit estimator and estimate
estimator = nml.CBPE(
    y_pred_proba='y_pred_proba',
    y_pred='y_pred',
    y_true='work_home_actual',
    metrics=['roc_auc'],
    chunk_size=chunk_size,
    problem_type='classification_binary',
)
estimator = estimator.fit(reference)
estimated_performance = estimator.estimate(analysis)

# Show results
figure = estimated_performance.plot(kind='performance', metric='roc_auc', plot_reference=True)
figure.show()

from colossalai.logging import get_dist_logger
from colossalai.trainer import Trainer, hooks

# build components and initialize with colossaalai.initialize
...

# create a logger so that trainer can log on thhe console
logger = get_dist_logger()

# create a trainer object
trainer = Trainer(
    engine=engine,
    logger=logger
)

import numpy as np
import emcee

def log_prob(x, ivar):
    return -0.5 * np.sum(ivar * x ** 2) 

ndim, nwalkers = 5, 100

ivar = 1./np.random.rand(ndim)
p0 = np.random.randn(nwalkers, ndim)

sampler = emcee.EnsembleSampler(nwalkers, ndim, log_prob, args=[ivar])
sampler.run_mcmc(p0, 10000)