def earnn(experiment='one_month_forecast',
include_pred_month=True,
surrounding_pixels=None,
pretrained=True):
# if the working directory is alread ml_drought don't need ../data
if Path('.').absolute().as_posix().split('/')[-1] == 'ml_drought':
data_path = Path('data')
else:
data_path = Path('../data')
if not pretrained:
predictor = EARecurrentNetwork(hidden_size=128,
data_folder=data_path,
experiment=experiment,
include_pred_month=include_pred_month,
surrounding_pixels=surrounding_pixels)
predictor.train(num_epochs=50, early_stopping=5)
predictor.evaluate(save_preds=True)
predictor.save_model()
else:
predictor = load_model(data_path /
f'models/{experiment}/ealstm/model.pt')
test_file = data_path / f'features/{experiment}/test/2018_3'
assert test_file.exists()
all_shap_for_file(test_file, predictor, batch_size=100)
def main(folder, out):
"""起動はこのフォルダ内から行う
フォルダに格納された画像に対して予測を行う
"""
dirs = os.listdir('images/test/')
weights = get_latestname("__checkpoints__/model_", 1)
n_classes = len(dirs)
model = load_model(n_classes=n_classes, weights=weights,
freeze='inference', basemodel=BASEMODEL)
df = pd.DataFrame()
images_path = glob.glob(os.path.join(folder, '*.jpg'))
print("-----"*4)
print(f"Detected {len(images_path)} images")
if not len(images_path):
print("No images detected")
return
for image_path in images_path:
name = os.path.basename(image_path)
image = prep_image(image_path)
image = image.reshape(TARGET_SIZE[0],
TARGET_SIZE[1], 3).reshape(1, TARGET_SIZE[0],
TARGET_SIZE[1], 3)
pred = model.predict(image)
print(name, pred)
df[name] = pred[0]
df.index = dirs
df = df.T
df.to_csv(out)
def earnn(
experiment="one_month_forecast",
include_pred_month=True,
surrounding_pixels=None,
pretrained=True,
ignore_vars=None,
include_static=True,
):
# if the working directory is alread ml_drought don't need ../data
if Path(".").absolute().as_posix().split("/")[-1] == "ml_drought":
data_path = Path("data")
else:
data_path = Path("../data")
if not pretrained:
predictor = EARecurrentNetwork(
hidden_size=128,
data_folder=data_path,
experiment=experiment,
include_pred_month=include_pred_month,
surrounding_pixels=surrounding_pixels,
ignore_vars=ignore_vars,
include_static=include_static,
)
predictor.train(num_epochs=50, early_stopping=10)
predictor.evaluate(save_preds=True)
predictor.save_model()
else:
predictor = load_model(data_path /
f"models/{experiment}/ealstm/model.pt")
def test_regression(self, tmp_path, monkeypatch):
coef_array = np.array([1, 1, 1, 1, 1])
intercept_array = np.array([2])
def mocktrain(self):
class MockModel:
@property
def coef_(self):
return coef_array
@property
def intercept_(self):
return intercept_array
self.model = MockModel()
monkeypatch.setattr(LinearRegression, 'train', mocktrain)
model = LinearRegression(tmp_path, experiment='one_month_forecast')
model.train()
model.save_model()
model_path = tmp_path / 'models/one_month_forecast/linear_regression/model.pkl'
assert model_path.exists(), f'Model not saved!'
new_model = load_model(model_path)
assert type(new_model) == LinearRegression
assert model.model.coef_ == coef_array
assert model.model.intercept_ == intercept_array
assert new_model.include_pred_month == model.include_pred_month
assert new_model.experiment == model.experiment
assert new_model.surrounding_pixels == model.surrounding_pixels
def earnn(
experiment="one_month_forecast",
include_pred_month=True,
surrounding_pixels=None,
pretrained=True,
ignore_vars=None,
):
data_path = get_data_path()
if not pretrained:
predictor = EARecurrentNetwork(
hidden_size=128,
data_folder=data_path,
experiment=experiment,
include_pred_month=include_pred_month,
surrounding_pixels=surrounding_pixels,
ignore_vars=ignore_vars,
)
predictor.train(num_epochs=50, early_stopping=5)
predictor.evaluate(save_preds=True)
predictor.save_model()
else:
predictor = load_model(data_path /
f"models/{experiment}/ealstm/model.pt")
test_file = data_path / f"features/{experiment}/test/2018_3"
assert test_file.exists()
all_explanations_for_file(test_file, predictor, batch_size=100)
def train_model(model_name='densenet121',
opt='Adagrad',
dataset='iris',
writer=None):
train_loader, val_loader, test_loader = load_data(dataset)
# Model selection
model = load_model(model_name)
# Optimizer
if model_name == "ownnet":
optimizer = opt_selection(model[0], opt)
else:
optimizer = opt_selection(model, opt)
# Loss Criterion
if dataset == 'mltoy' or dataset == "yeast14c" or dataset == "yeast14c_m":
# criterion = nn.MultiLabelSoftMarginLoss()
criterion = nn.BCEWithLogitsLoss()
else:
criterion = nn.CrossEntropyLoss()
if model_name == "ownnet":
criterion = torch.nn.MSELoss()
best_train, best_val = 0.0, 0.0
g = 0
for epoch in range(1, args.epochs + 1):
# Train and Validate
train_stats = train_step(model, criterion, optimizer, train_loader, g,
epoch)
valid_stats = valid_step(model, criterion, val_loader)
g += 1
# Logging
logging(epoch, train_stats, valid_stats, writer)
# Keep best model
# print(train_stats['accuracy'], valid_stats['accuracy'], best_train, best_val)
if valid_stats['accuracy'] > best_val or (
valid_stats['accuracy'] == best_val
and train_stats['accuracy'] >= best_train):
best_train = train_stats['accuracy']
best_val = valid_stats['accuracy']
if model_name == "ownnet":
best_model_weights = copy.deepcopy(model[0].state_dict())
else:
best_model_weights = copy.deepcopy(model.state_dict())
# Load best model and evaluate on test set
model.load_state_dict(best_model_weights)
test_stats = valid_step(model, criterion, test_loader)
# print(train_stats['accuracy'], valid_stats['accuracy'], best_train, best_val)
print(
'\nBests Model Accuracies: Train: {:4.2f} | Val: {:4.2f} | Test: {:4.2f}'
.format(best_train, best_val, test_stats['accuracy']))
return model
def earnn(
experiment="one_month_forecast",
include_pred_month=True,
surrounding_pixels=None,
pretrained=False,
explain=False,
static="features",
ignore_vars=None,
num_epochs=50,
early_stopping=5,
static_embedding_size=10,
hidden_size=128,
predict_delta=False,
spatial_mask=None,
include_latlons=False,
normalize_y=True,
include_prev_y=True,
include_yearly_aggs=True, # new
clear_nans=True,
weight_observations=False,
pred_month_static=False,
):
data_path = get_data_path()
if not pretrained:
predictor = EARecurrentNetwork(
hidden_size=hidden_size,
data_folder=data_path,
experiment=experiment,
include_pred_month=include_pred_month,
surrounding_pixels=surrounding_pixels,
static=static,
static_embedding_size=static_embedding_size,
ignore_vars=ignore_vars,
predict_delta=predict_delta,
spatial_mask=spatial_mask,
include_latlons=include_latlons,
normalize_y=normalize_y,
include_prev_y=include_prev_y,
include_yearly_aggs=include_yearly_aggs,
clear_nans=clear_nans,
weight_observations=weight_observations,
pred_month_static=pred_month_static,
)
predictor.train(num_epochs=num_epochs, early_stopping=early_stopping)
predictor.evaluate(save_preds=True)
predictor.save_model()
else:
predictor = load_model(data_path /
f"models/{experiment}/ealstm/model.pt")
if explain:
test_file = data_path / f"features/{experiment}/test/2018_3"
assert test_file.exists()
all_explanations_for_file(test_file, predictor, batch_size=100)
def main(
config_path: Path,
input_path: Path,
model_path: Path,
predict_path: Path,
val_loader: Optional[DataLoader] = None,
) -> Path:
"""
Main function responsible for prediction with passed model.
Arguments:
Path config_path: Path to main config (of :class:`DefaultConfig` class)
Path input_path: Path to file with input data
Path model_path: Path to trained model
Path predict_path: Path to output directory
Returns:
Path to the experiment root dir.
"""
config = load_variable("config", config_path)
if val_loader is None:
pipeline = False
_, val_loader, _ = DataLoader.get_loaders(input_path, config=config)
else:
pipeline = True
is_image_folder = image_folder(val_loader.dataset)
model: Module = load_model(config, model_path)
model.eval()
all_preds = torch.tensor([])
for inputs, labels in tqdm(val_loader, desc="Predictions"):
if not is_image_folder and not pipeline:
inputs, _ = input_transform(
input_data=inputs,
input_labels=labels,
preprocessors=config.preprocessors,
)
predictions = model(inputs)
processed_preds = pred_transform(predictions, config.postprocessors)
all_preds = torch.cat([all_preds, processed_preds])
save_prediction(predictions=all_preds, output_path=predict_path)
return SimpleNamespace(root=predict_path.parent.parent)
def test_rnn(self, tmp_path, monkeypatch):
features_per_month = 5
dense_features = [10]
hidden_size = 128
rnn_dropout = 0.25
dense_dropout = 0.25
include_pred_month = True
def mocktrain(self):
self.model = RNN(
features_per_month,
dense_features,
hidden_size,
rnn_dropout,
dense_dropout,
include_pred_month,
experiment="one_month_forecast",
)
self.features_per_month = features_per_month
monkeypatch.setattr(RecurrentNetwork, "train", mocktrain)
model = RecurrentNetwork(
hidden_size=hidden_size,
dense_features=dense_features,
rnn_dropout=rnn_dropout,
data_folder=tmp_path,
)
model.train()
model.save_model()
model_path = tmp_path / "models/one_month_forecast/rnn/model.pkl"
assert model_path.exists(), "Model not saved!"
new_model = load_model(model_path)
assert type(new_model) == RecurrentNetwork
for key, val in new_model.model.state_dict.items():
assert (model.model.state_dict()[key] == val).all()
assert new_model.dense_features == model.dense_features
assert new_model.features_per_month == model.features_per_month
assert new_model.hidden_size == model.hidden_size
assert new_model.rnn_dropout == model.rnn_dropout
assert new_model.include_pred_month == model.include_pred_month
assert new_model.experiment == model.experiment
assert new_model.surrounding_pixels == model.surrounding_pixels
def load(log_dir: str, model_type: str):
global MODEL, PREPROCESSOR
if model_type == "lstm":
model_path = os.path.join(log_dir, "model.h5")
else:
model_path = os.path.join(log_dir, "saved_model/model")
preprocessor_path = os.path.join(log_dir, "preprocessor.pkl")
if not os.path.exists(model_path) or not os.path.exists(preprocessor_path):
raise Exception(
"Please run `train.py` before building the app. Or make sure the needed files exist"
)
MODEL = load_model(model_path)
PREPROCESSOR = Preprocessor.load(preprocessor_path)
assert MODEL is not None, "Model has not been properly loaded"
assert PREPROCESSOR is not None, "Preprocessor has not been properly loaded"
def debug_model(category, category_dir, labels, mode):
print("Start:", category)
images_path = glob.glob(os.path.join('images', 'test', category, '*.jpg'))
n_classes = os.listdir('images/train')
trained_weight = get_latestname("__checkpoints__/model_", 1)
model = load_model(len(n_classes),
trained_weight,
freeze='inference',
basemodel=BASEMODEL)
for image_path in images_path:
image = prep_image(image_path)
name = pathlib.Path(image_path).name
prediction = model.predict(image)
predicted_label = labels[np.argmax(prediction)]
true_label = category
if predicted_label == true_label:
continue
image = image.reshape(TARGET_SIZE[0], TARGET_SIZE[1], 3)
explainer = lime_image.LimeImageExplainer()
explanation = explainer.explain_instance(image,
model.predict,
top_labels=len(n_classes),
hide_color=0,
num_samples=NUM_SAMPLES)
if mode == 'RedGreen':
temp, mask = explanation.get_image_and_mask(
explanation.top_labels[0],
positive_only=False,
num_features=10,
hide_rest=False)
elif mode == 'simple':
temp, mask = explanation.get_image_and_mask(
explanation.top_labels[0],
positive_only=True,
num_features=5,
hide_rest=False)
image = mark_boundaries(temp * 0.7 + 0.3, mask) * 255
image = Image.fromarray(np.uint8(image))
image.save(
os.path.join(category_dir, "[" + predicted_label + "]_" + name))
def __init__(self, model, features_path, database_path=None):
# Load the extraction model
self.model = load_model(model)
# Load the feature metadata
features_basename = basename(features_path)
meta_file_path = join(features_path,
'{}.meta'.format(features_basename))
with open(meta_file_path, 'r') as f:
self.feature_metadata = json.load(f)
# Load image representations
repr_file_path = join(features_path,
'{}.repr.npy'.format(features_basename))
self.feature_store = np.load(repr_file_path)
if representation_size(self.model) != self.feature_store.shape[-1]:
raise ValueError('Model {} and feature store {} have nonmatching '
'representation sizes: {} vs {}'.format(
model, features_path,
representation_size(self.model),
self.feature_store.shape[-1]))
# Construct paths to feature files
self.feature_file_paths = {}
features_sub_folder = join(features_path, 'features/')
for idx, metadata in self.feature_metadata.items():
if not idx.isdigit():
continue
image_name = basename(self.feature_metadata[str(idx)]['image'])
path = join(features_sub_folder, '{}.npy'.format(image_name))
if isfile(path):
self.feature_file_paths[str(idx)] = path
else:
print('Missing feature file for image {}'.format(image_name))
# Load PCA
pca_file_path = join(features_path, '{}.pca'.format(features_basename))
if isfile(pca_file_path):
self.pca = joblib.load(pca_file_path)
else:
self.pca = None
# Load image database
if database_path:
self.database = Database.load(database_path)
else:
self.database = None
def inference_testdata():
dirs = os.listdir('images/test/')
weights = get_latestname("__checkpoints__/model_", 1)
model = load_model(n_classes=len(dirs),
weights=weights,
freeze='inference',
basemodel=BASEMODEL)
testGene = DummyGenerator(
batch_size=1,
train_path='__dataset__',
image_folder='test',
aug_dict=None,
save_to_dir=None,
shuffle=False,
target_size=TARGET_SIZE,
image_color_mode="rgb",
)
filenames = testGene.filenames
category_names = [pathlib.Path(fname).parts[-2] for fname in filenames]
nb_samples = len(filenames)
if not nb_samples:
print("No images found")
return
predict = model.predict_generator(testGene, steps=nb_samples)
columns = list(testGene.class_indices.keys())
df_predict = pd.DataFrame(predict, columns=columns)
df_predict['Pred'] = df_predict.idxmax(1)
df_predict['True'] = category_names
df_predict['Score'] = (df_predict['Pred'] == df_predict['True']).apply(int)
df_predict.index = filenames
df_predict.to_csv('__checkpoints__/test_result.csv')
print("--" * 20)
print("")
print("Total Score:", df_predict['Score'].mean())
for label in set(list(df_predict["True"])):
score = df_predict.loc[df_predict['True'] == label, "Score"].mean()
print(f"{label} Score:", score)
print("")
print("--" * 20)
def main() -> None:
print(f"Running DeepLIFT for {EXPERIMENT}")
data_dir = get_data_path()
# 1. open the model
model = load_model(data_dir / "models" / EXPERIMENT / MODEL / "model.pt")
model.models_dir = data_dir / "models" / EXPERIMENT
model.experiment = TRUE_EXPERIMENT
# 2. get all the TEST timesteps in the test directory
test_folders = [d for d in (data_dir / f"features/{EXPERIMENT}/test").iterdir()]
# TODO: remove this test
# test_folders = test_folders[:2]
# 3. run the shap analysis for each test timestep
for test_folder in test_folders:
print(f"\n\n** Working on {test_folder.name} **\n\n")
run_shap_for_folder(data_dir, test_folder, model) # type: ignore
def test_linear_network(self, tmp_path, monkeypatch):
layer_sizes = [10]
input_size = 10
dropout = 0.25
include_pred_month = True
surrounding_pixels = 1
def mocktrain(self):
self.model = LinearModel(
input_size, layer_sizes, dropout, include_pred_month
)
self.input_size = input_size
monkeypatch.setattr(LinearNetwork, "train", mocktrain)
model = LinearNetwork(
data_folder=tmp_path,
layer_sizes=layer_sizes,
dropout=dropout,
experiment="one_month_forecast",
include_pred_month=include_pred_month,
surrounding_pixels=surrounding_pixels,
)
model.train()
model.save_model()
model_path = tmp_path / "models/one_month_forecast/linear_network/model.pkl"
assert model_path.exists(), "Model not saved!"
new_model = load_model(model_path)
assert type(new_model) == LinearNetwork
for key, val in new_model.model.state_dict.items():
assert (model.model.state_dict()[key] == val).all()
assert new_model.dense_features == model.dense_features
assert new_model.features_per_month == model.input_size
assert new_model.hidden_size == model.dropout
assert new_model.include_pred_month == model.include_pred_month
assert new_model.experiment == model.experiment
assert new_model.surrounding_pixels == model.surrounding_pixels
def train_model(model_name='densenet121',
opt='Adagrad',
dataset='iris',
writer=None,
label_col_name=''):
# train_loader, val_loader, test_loader = load_data(dataset, label_col_name=label_col_name)
train_loader, test_loader, nb_classes = load_data(
dataset, label_col_name=label_col_name)
# Model selection
model = load_model(model_name, nb_classes=nb_classes)
# Optimizer
optimizer = opt_selection(model, opt)
# Loss Criterion
criterion = nn.CrossEntropyLoss()
best_train, best_val = 0.0, 0.0
for epoch in range(1, args.epochs + 1):
# Train and Validate
train_stats = train_step(model, criterion, optimizer, train_loader)
# valid_stats = valid_step(model, criterion, val_loader)
# Logging
# logging(epoch, train_stats, valid_stats, writer)
logging(epoch, train_stats, writer)
# Keep best model
if train_stats['accuracy'] >= best_train:
best_train = train_stats['accuracy']
# best_val = valid_stats['accuracy']
best_model_weights = copy.deepcopy(model.state_dict())
# Load best model and evaluate on test set
model.load_state_dict(best_model_weights)
test_stats = valid_step(model, criterion, test_loader)
# print('\nBests Model Accuracies: Train: {:4.2f} | Val: {:4.2f} | Test: {:4.2f}'.format(best_train, best_val, test_stats['accuracy']))
print('\nBests Model Accuracies: Train: {:4.2f} | Test: {:4.2f}'.format(
best_train, test_stats['accuracy']))
return model
def main(folderpath):
dirs = os.listdir('images/test/')
weights = get_latestname("__checkpoints__/model_", 1)
n_classes = len(dirs)
model = load_model(n_classes=n_classes,
weights=weights,
freeze='inference',
basemodel=BASEMODEL)
df = pd.DataFrame()
images_path = glob.glob(folderpath + '/*')
for image_path in images_path:
name = os.path.basename(image_path)
image = prep_image(image_path)
pred, uncert = prediction(model, n_classes, image)
df[name + "_pred"] = pred
df[name + "_var"] = uncert
df.index = dirs
df.to_csv('inference.csv')
def test_xgboost(self, tmp_path, monkeypatch):
import xgboost as xgb
def mocktrain(self):
self.model = xgb.XGBRegressor()
monkeypatch.setattr(GBDT, "train", mocktrain)
model = GBDT(tmp_path, experiment="one_month_forecast")
model.train()
model.save_model()
model_path = tmp_path / "models/one_month_forecast/gbdt/model.pkl"
assert model_path.exists(), f"Model not saved!"
new_model = load_model(model_path)
assert type(new_model) == GBDT
assert new_model.include_pred_month == model.include_pred_month
assert new_model.experiment == model.experiment
assert new_model.surrounding_pixels == model.surrounding_pixels
def extract_conv_features(name, model_name, features_dir, image_dir, root_dir):
"""Extracts features of all images in image_dir and
saves them for later use.
"""
image_dir = os.path.abspath(image_dir)
out_dir = join(features_dir, 'features/')
if not exists(out_dir):
os.mkdir(out_dir)
extensions = ['.png', '.jpg', '.jpeg']
images = os.listdir(image_dir)
images = [
img for img in images if os.path.splitext(img)[1].lower() in extensions
]
images = sorted(images)
model = load_model(model_name)
meta_data = {'model': model_name}
for idx, image_name in enumerate(images):
print('{}/{}: extracting features of image {}'.format(
idx + 1, len(images), image_name))
image_path = join(image_dir, image_name)
image = load_image(image_path)
features = compute_features(model, image)
np.save(join(out_dir, os.path.basename(image_name)), features)
meta_data[idx] = {
'image': os.path.relpath(image_path, root_dir),
'height': image.shape[0],
'width': image.shape[1]
}
meta_file_name = '{}.meta'.format(name)
with open(join(features_dir, meta_file_name), 'w') as f:
json.dump(meta_data, f)
def __init__(self, params: PredictionPipelineParams):
self.pipeline = load_transformer(params.transformer_path)
self.model = load_model(params.model_path)
def main(args=None):
# parse arguments
if args is None:
args = sys.argv[1:]
args = parse_args(args)
# make sure keras is the minimum required version
check_keras_version()
# optionally choose specific GPU
if args.gpu:
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
keras.backend.tensorflow_backend.set_session(get_session())
# make save path if it doesn't exist
if args.save_path is not None and not os.path.exists(args.save_path):
os.makedirs(args.save_path)
# optionally load config parameters
if args.config:
args.config = read_config_file(args.config)
# create the generator
generator = create_generator(args)
# optionally load anchor parameters
anchor_params = None
if args.config and 'anchor_parameters' in args.config:
anchor_params = parse_anchor_parameters(args.config)
# load the model
print('Loading model, this may take a second...')
model = models.load_model(args.model, backbone_name=args.backbone)
# optionally convert the model
if args.convert_model:
model = models.convert_model(model, anchor_params=anchor_params)
# print model summary
# print(model.summary())
# start evaluation
if args.dataset_type == 'coco':
from ..utils.coco_eval import evaluate_coco
evaluate_coco(generator, model, args.score_threshold)
else:
average_precisions = evaluate(
generator,
model,
iou_threshold=args.iou_threshold,
score_threshold=args.score_threshold,
max_detections=args.max_detections,
save_path=args.save_path
)
# print evaluation
total_instances = []
precisions = []
for label, (average_precision, num_annotations) in average_precisions.items():
print('{:.0f} instances of class'.format(num_annotations),
generator.label_to_name(label), 'with average precision: {:.4f}'.format(average_precision))
total_instances.append(num_annotations)
precisions.append(average_precision)
if sum(total_instances) == 0:
print('No test instances found.')
return
print('mAP using the weighted average of precisions among classes: {:.4f}'.format(sum([a * b for a, b in zip(total_instances, precisions)]) / sum(total_instances)))
print('mAP: {:.4f}'.format(sum(precisions) / sum(x > 0 for x in total_instances)))
def __init__(self):
model_path = 'data/inference.h5'
self.model = models.load_model(model_path, backbone_name='resnet50')
self.labels_to_names = {0: 'crack', 1: 'wrinkle'}
self.threshold = 0.50
ealstm.evaluate(
spatial_unit_name='station_id',
save_preds=True
)
results_dict = json.load(open('data/models/one_timestep_forecast/ealstm/results.json', 'rb'))
print("Overall RMSE: ", results_dict['total'])
# 1 epoch = 1.04 / 2.81
# 100 epochs = 0.72 / 2.04
# save the model
ealstm.save_model()
# load the model
from src.models import load_model
ealstm2 = load_model(Path('data/models/one_timestep_forecast/ealstm/model.pt'))
# ------------------------------------------------------------------------
## ANALYSIS
# ------------------------------------------------------------------------
import matplotlib.pyplot as plt
# checking the performance of the models
EXPERIMENT = 'one_timestep_forecast'
from src.analysis import read_pred_data
from src.analysis.evaluation import join_true_pred_da
# making predictions
ealstm_pred = read_pred_data('ealstm', data_dir, experiment=EXPERIMENT)
ealstm_pred['station_id'] = ealstm_pred['station_id'].astype(int)
import xarray as xr
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from pathlib import Path
import sys
%load_ext autoreload
%autoreload 2
%matplotlib
data_dir = data_path = Path('data')
data_dir = data_path = Path('/Volumes/Lees_Extend/data/ecmwf_sowc/data')
sys.path.append('/Users/tommylees/github/ml_drought')
# load model
from src.models import load_model
model_path = data_dir / 'models/one_month_forecast/ealstm/model.pt'
assert model_path.exists()
ealstm = load_model(model_path)
# load X / Y data
from src.analysis import read_train_data, read_test_data
X_train, y_train = read_train_data(data_dir)
X_test, y_test = read_test_data(data_dir)
def run_training():
acc_train = []
acc_val = []
trainGene = customGenerator(
batch_size=BATCH_SIZE,
train_path='__dataset__',
image_folder='train',
aug_dict=DATA_GEN_DEFAULT,
save_to_dir=None,
target_size=TARGET_SIZE,
image_color_mode="rgb",
)
validGene = customGenerator(
batch_size=BATCH_SIZE,
train_path='__dataset__',
image_folder='valid',
aug_dict=None,
save_to_dir=None,
target_size=TARGET_SIZE,
image_color_mode="rgb",
)
if os.path.exists("__checkpoints__"):
shutil.rmtree("__checkpoints__")
os.makedirs("__checkpoints__")
hdfname = get_uniquename("__checkpoints__/model_", 1)
model_checkpoint = ModelCheckpoint('{}.hdf5'.format(hdfname),
monitor='loss',
verbose=1,
save_best_only=True)
early_stopping = EarlyStopping(monitor='val_loss',
min_delta=0,
patience=EA_EPOCHS,
verbose=0,
mode='auto')
callbacks = [early_stopping, model_checkpoint]
n_classes = len(os.listdir('__dataset__/train/'))
n_train_images = len(glob.glob('__dataset__/train/*/*'))
n_valid_images = len(glob.glob('__dataset__/valid/*/*'))
print("ベースモデル凍結：訓練開始")
trained_weight = get_latestname("__checkpoints__/model_", 1)
model = load_model(n_classes,
trained_weight,
freeze='initial',
basemodel=BASEMODEL)
history = model.fit_generator(trainGene,
steps_per_epoch=n_train_images // BATCH_SIZE,
epochs=INITIAL_EPOCHS,
validation_data=validGene,
validation_steps=n_valid_images //
BATCH_SIZE,
callbacks=callbacks)
acc_train = acc_train + list(history.history['acc'])
acc_val = acc_val + list(history.history['val_acc'])
n_epoch_1 = len(list(history.history['acc']))
print("初期訓練の終了：モデルのリロードを開始")
trained_weight = get_latestname("__checkpoints__/model_", 1)
print("検出したモデル：", trained_weight)
model = load_model(n_classes,
weights=trained_weight,
freeze='second',
basemodel=BASEMODEL)
print("2つのinceptionブロックを解凍：訓練再開")
history = model.fit_generator(trainGene,
steps_per_epoch=n_train_images // BATCH_SIZE,
epochs=SECOND_EPOCHS,
validation_data=validGene,
validation_steps=n_valid_images //
BATCH_SIZE,
callbacks=callbacks)
acc_train = acc_train + list(history.history['acc'])
acc_val = acc_val + list(history.history['val_acc'])
n_epoch_2 = len(list(history.history['acc']))
print("第二次訓練の終了：モデルのリロードを開始")
trained_weight = get_latestname("__checkpoints__/model_", 1)
print("検出したモデル：", trained_weight)
model = load_model(n_classes,
weights=trained_weight,
freeze='third',
basemodel=BASEMODEL)
print("4つのinceptionブロックを解凍：訓練再開")
trainGene = customGenerator(
batch_size=BATCH_SIZE,
train_path='__dataset__',
image_folder='train',
aug_dict=DATA_GEN_DEFAULT,
save_to_dir=None,
target_size=TARGET_SIZE,
image_color_mode="rgb",
)
validGene = customGenerator(
batch_size=BATCH_SIZE,
train_path='__dataset__',
image_folder='valid',
aug_dict=None,
save_to_dir=None,
target_size=TARGET_SIZE,
image_color_mode="rgb",
)
history = model.fit_generator(trainGene,
steps_per_epoch=n_train_images // BATCH_SIZE,
epochs=THIRD_EPOCHS,
validation_data=validGene,
validation_steps=n_valid_images //
BATCH_SIZE,
callbacks=callbacks)
acc_train = acc_train + list(history.history['acc'])
acc_val = acc_val + list(history.history['val_acc'])
n_epoch_3 = len(list(history.history['acc']))
print("第三次訓練の終了：モデルのリロードを開始")
trained_weight = get_latestname("__checkpoints__/model_", 1)
print("検出したモデル：", trained_weight)
model = load_model(n_classes,
weights=trained_weight,
freeze='final',
basemodel=BASEMODEL)
print("すべてのinceptionブロックを解凍：訓練再開")
trainGene = customGenerator(
batch_size=BATCH_SIZE,
train_path='__dataset__',
image_folder='train',
aug_dict=DATA_GEN_DEFAULT,
save_to_dir=None,
target_size=TARGET_SIZE,
image_color_mode="rgb",
)
validGene = customGenerator(
batch_size=BATCH_SIZE,
train_path='__dataset__',
image_folder='valid',
aug_dict=None,
save_to_dir=None,
target_size=TARGET_SIZE,
image_color_mode="rgb",
)
history = model.fit_generator(trainGene,
steps_per_epoch=n_train_images // BATCH_SIZE,
epochs=FINAL_EPOCHS,
validation_data=validGene,
validation_steps=n_valid_images //
BATCH_SIZE,
callbacks=callbacks)
acc_train = acc_train + list(history.history['acc'])
acc_val = acc_val + list(history.history['val_acc'])
n_epoch_4 = len(list(history.history['acc']))
print("訓練の正常終了")
print("acc train:", acc_train)
print("acc validation:", acc_val)
epochs = range(1, len(acc_train) + 1)
plt.plot(epochs, acc_train, label='train')
plt.plot(epochs, acc_val, label='valid')
#: トレーニングの区切り
plt.plot([n_epoch_1, n_epoch_1], [0, 1.0],
"--",
color='darkred',
alpha=0.7)
plt.plot([n_epoch_1 + n_epoch_2, n_epoch_1 + n_epoch_2], [0, 1.0],
"--",
color='darkred',
alpha=0.7)
plt.plot(
[n_epoch_1 + n_epoch_2 + n_epoch_3, n_epoch_1 + n_epoch_2 + n_epoch_3],
[0, 1.0],
"--",
color='darkred',
alpha=0.7)
plt.plot([
n_epoch_1 + n_epoch_2 + n_epoch_3 + n_epoch_4,
n_epoch_1 + n_epoch_2 + n_epoch_3 + n_epoch_4
], [0, 1.0],
"--",
color='darkred',
alpha=0.7)
plt.legend()
plt.savefig('__checkpoints__/training_history.png')
shutil.copy('config.py', '__checkpoints__/')
def load_nn(data_dir: Path,
model_str: str,
experiment: str = "one_month_forecast") -> NNBase:
return load_model(data_dir / f"models/{experiment}/{model_str}/model.pt")
sys.path.append("../..")
from scripts.utils import _rename_directory, get_data_path
from src.models import load_model
#
data_dir = get_data_path()
# experiment names
EXPERIMENT = "one_month_forecast_BASE_static_vars"
TRUE_EXPERIMENT = "one_month_forecast_BOKU_boku_VCI_our_vars_ALL"
TARGET_VAR = "boku_VCI"
# load EALSTM model
ealstm = load_model(data_dir / "models" / EXPERIMENT / "ealstm" / "model.pt")
ealstm.models_dir = data_dir / "models" / EXPERIMENT
ealstm.experiment = TRUE_EXPERIMENT
# load static embeddings
from typing import Tuple
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def build_static_x(
x: Tuple[np.array],
) -> Tuple[List[np.array], List[np.array], List[np.array]]:
all_static_x = []
caption = "{} {:.3f}".format(labels_to_names[label], score)
# draw_caption(draw, b, caption)
print(caption, b)
# draw_text(box, draw, labels_to_names[label], [255,255,0], 0, -45, 1, 1)
cv2.putText(draw, caption, (box[0], box[1]),
cv2.FONT_HERSHEY_SIMPLEX, 5, (255, 255, 0), 5,
cv2.LINE_8)
plt.figure(figsize=(15, 15))
plt.axis('off')
plt.imshow(draw)
plt.show()
filename, _ = os.path.basename(file_path).split(".")
dirname = os.path.dirname(file_path)
dest = os.path.join(
dirname, filename + "_" + labels_to_names[label] + ".jpg")
if save:
cv2.imwrite(dest, draw)
if __name__ == "__main__":
model = models.load_model('data/inference.h5', backbone_name='resnet50')
labels_to_names = {0: 'crack', 1: 'wrinkle'}
im_path = 'data/images/'
for file in os.listdir(im_path):
file_path = os.path.join(im_path, file)
predict_save(file_path, model, save=True)
def main(
root_path: Path,
experiments: str,
model_paths: str,
input_path: Path,
predict_path: Path,
config_path: Path,
evaluate_path: Path,
) -> Path:
"""
Main function responsible for prediction with passed model.
Arguments:
Path root_path: Path to the root folder for the subprocess
str experiment_paths: Relative paths to experiments separated by coma
Path model_path: Subpath to trained model
Path input_path: Path to file with input data
Path predict_path: Path to output directory
Path config_path: Path to main config (of :class:`DefaultConfig` class)
Path evaluate_path: Path to evaluations
Returns:
Path to the experiment root dir.
"""
models_with_config = []
data_type = None
prediction_bs = None
main_config = None
zipped = zip(unpack_string(experiments), unpack_string(model_paths))
for index, (experiment, model_path) in enumerate(zipped):
config_paths = (root_path / experiment / config_path).iterdir()
config = get_config(config_paths)
if index == 0:
main_config = config
model = load_model(config, root_path / experiment / model_path)
model.eval()
models_with_config.append(dict(model=model, config=config))
data_type = set_param(previous=data_type,
current=config.training.dtype,
name="dtype")
prediction_bs = set_param(
previous=prediction_bs,
current=config.prediction.batch_size,
name="batch_size",
)
_, val_loader, _ = DataLoader.get_loaders(input_path, config=main_config)
model_preds = []
for model_with_config in models_with_config:
model = model_with_config["model"]
config = model_with_config["config"]
all_preds = torch.tensor([])
for x, _ in tqdm(val_loader, desc="Predictions"):
predictions = model(x)
processed_preds = pred_transform(
preds=predictions, postprocessors=config.postprocessors)
all_preds = torch.cat([all_preds, processed_preds])
model_preds.append(all_preds)
predictions = two_classifiers(model_preds, loader=val_loader)
save_prediction(
predictions=predictions,
output_path=root_path / predict_path,
)
if evaluate_path:
logger.info("Evaluator")
evaluate(
config=main_config,
input_path=input_path,
predict_path=root_path / predict_path,
evaluate_path=root_path / evaluate_path,
val_loader=val_loader,
)
