def swap_faces(image_a_path, image_b_path):
image_a, image_b = load_images([
os.path.join(IMAGES_FOLDER, 'trump', image_a_path),
os.path.join(IMAGES_FOLDER, 'cage', image_b_path)]
) / 255.0
image_a += images_B_mean - images_A_mean
image_b += images_A_mean - images_B_mean
# Preprocess loaded images
image_a = cv2.resize(image_a, (64, 64))
image_b = cv2.resize(image_b, (64, 64))
image_a = toTensor(image_a).to(device).float()
image_b = toTensor(image_b).to(device).float()
# Forward with opposite encoders
result_a = var_to_np(model(image_a, 'B'))
result_b = var_to_np(model(image_b, 'A'))
result_a = np.moveaxis(np.squeeze(result_a), 0, 2)
result_b = np.moveaxis(np.squeeze(result_b), 0, 2)
result_a = np.clip(result_a * 255, 0, 255).astype('uint8')
result_b = np.clip(result_b * 255, 0, 255).astype('uint8')
image_a_filename = os.path.splitext(image_a_path)[0]
image_b_filename = os.path.splitext(image_b_path)[0]
result_a_filename = f'{image_a_filename}-{image_b_filename}.jpg'
result_b_filename = f'{image_b_filename}-{image_a_filename}.jpg'
cv2.imwrite(os.path.join(SWAPS_FOLDER, result_a_filename), result_a)
cv2.imwrite(os.path.join(SWAPS_FOLDER, result_b_filename), result_b)
return result_a_filename, result_b_filename
def get_next(pre_words):
model.zero_grad()
state = model.init_hidden(1)
# batch_size should be 1 since we generate each word in sequence
sorted_lengths = [1]
ouput_batch = None
words = [word for word in pre_words]
print(words)
next_word = ''
# input pre_words
for w in words:
yield w
input_batch = torch.LongTensor([provider.vocab[w]]).view(1, 1)
input_batch = Variable(input_batch)
output_batch, state = model(input_batch, sorted_lengths)
output_seqs = parse_batch(output_batch)
next_word = output_seqs[0]
yield next_word
# predict
while True:
input_batch = torch.LongTensor([provider.vocab[next_word]]).view(1, 1)
input_batch = Variable(input_batch)
output_batch, state = model(input_batch, sorted_lengths)
output_seqs = parse_batch(output_batch)
next_word = output_seqs[0]
# [0] since our batch size is only 1
yield next_word
def start_training(files_benign, train_benign, files_malware, train_malware):
with open("base.txt", "w") as f:
for item in train_benign:
f.write(files_benign[item] + "\n")
with open("input.txt", "w") as f:
for item in train_malware:
f.write(files_malware[item] + "\n")
train.model()
print(
"\n..................................................................................................................\n"
)
def evaluate(self, dataloader, epoch):
model.eval()
val_loss_value = 0
with torch.no_grad():
for batch in dataloader:
anchor_embedding = model(batch["anchor"])
positive_embedding = model(batch["positive"])
negative_embedding = model(batch["negative"])
loss = self.criterion(anchor_embedding, positive_embedding,
negative_embedding)
val_loss_value += loss.item()
val_epoch_loss = val_loss_value / len(dataloader)
return val_epoch_loss
def train(self, dataloader, epoch):
model.train()
losses = 0
for batch in tqdm(dataloader, total=len(dataloader)):
model.zero_grad()
anchor_embedding = model(batch["anchor"])
positive_embedding = model(batch["positive"])
negative_embedding = model(batch["negative"])
loss = self.criterion(anchor_embedding, positive_embedding,
negative_embedding)
loss.backward()
self.optimizer.step()
losses += loss.item()
epoch_loss = losses / len(dataloader)
return epoch_loss
def sample_iteration(config, rng, params, sample):
"""PixelCNN++ sampling expressed as a fixed-point iteration."""
rng, dropout_rng = random.split(rng)
out = train.model(config).apply({'params': params},
sample,
rngs={'dropout': dropout_rng})
c_params = pixelcnn.conditional_params_from_outputs(out, sample)
return conditional_params_to_sample(rng, c_params)
def summarize_embedding(self, dataloader, writer, epoch):
model.eval()
with torch.no_grad():
for batch in dataloader:
embeddings = model(batch["image"])
writer.add_embedding(embeddings,
global_step=epoch,
label_img=batch["image"])
def compare_results(input_list):
print(
sorted([get_score(u) for u in input_list],
key=lambda x: x[1],
reverse=True))
M = model()
print([(u[0], u[1]) for u in sort_list(input_list, M)])
def load_model(x, fold):
_, f, _ = model(x, len(cfg.ml_variables), 1, fold)
variables = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,
scope='model_fold{}'.format(fold))
path = tf.train.latest_checkpoint(
os.path.join(workdir, 'model_fold{}'.format(fold)))
print('Load variables for fold {} from {}'.format(fold, path))
saver = tf.train.Saver(variables)
saver.restore(session, path)
return f
def predict_model_batch(model, batch, label, result_csv, device=device):
b_input_ids = batch[0].to(device)
b_input_mask = batch[1].to(device)
b_labels = batch[2].to(device)
with torch.no_grad():
res = model(b_input_ids,
token_type_ids=None,
attention_mask=b_input_mask,
labels=b_labels)
loss, logits = res['loss'], res['logits'].cpu().numpy()
prediction = list(np.argmax(logits, axis=1).flatten())
result_csv[label] += prediction
def main(args):
inv_fold = [1, 0][args.fold]
x, y, w = build_dataset(os.path.join(args.workdir,
'fold{}.root'.format(inv_fold)),
cfg.ml_classes,
inv_fold,
make_categorical=False,
use_class_weights=True)
preproc = pickle.load(
open(
os.path.join(args.workdir,
'preproc_fold{}.pickle'.format(args.fold)), 'rb'))
x_preproc = preproc.transform(x)
x_ph = tf.placeholder(tf.float32)
_, f = model(x_ph, len(cfg.ml_variables), len(cfg.ml_classes), args.fold)
path = tf.train.latest_checkpoint(
os.path.join(args.workdir, 'model_fold{}'.format(args.fold)))
logger.debug('Load model {}'.format(path))
config = tf.ConfigProto(intra_op_parallelism_threads=12,
inter_op_parallelism_threads=12)
session = tf.Session(config=config)
saver = tf.train.Saver()
saver.restore(session, path)
p = session.run(f, feed_dict={x_ph: x_preproc})
p = np.argmax(p, axis=1)
c = confusion_matrix(y, p, sample_weight=w)
logger.debug('Confusion matrix (plain): {}'.format(c))
plot(c, 'plain')
c_norm_rows = c.copy()
c_norm_cols = c.copy()
for i in range(c.shape[0]):
c_norm_rows[:, i] = c_norm_rows[:, i] / np.sum(c_norm_rows[:, i])
c_norm_cols[i, :] = c_norm_cols[i, :] / np.sum(c_norm_cols[i, :])
logger.debug('Confusion matrix (norm rows): {}'.format(c_norm_rows))
plot(c_norm_rows, 'norm_rows')
logger.debug('Confusion matrix (norm cols): {}'.format(c_norm_cols))
plot(c_norm_cols, 'norm_cols')
c_norm_all = c / np.sum(w)
logger.debug('Confusion matrix (norm all): {}'.format(c_norm_all))
plot(c_norm_all, 'norm_all')
def gen_poem(begin_word, file, models, poem_type):
tf.reset_default_graph()
n = [24, 48, 32, 64]
List = ['5jue', '5lv', '7jue', '7lv']
if poem_type in List:
m = n[List.index(poem_type)] # 选择对应的模型
batch_size = 1
print('loading model from %s' % models)
vector, word_dic, words = process_poetry(file, poem_type) # 将对应数据集数字化
input_data = tf.placeholder(tf.int32, [batch_size, None])
loss, initial_state, last_state = model(input_data=input_data,
words_len=len(words),
rnn_size=128,
num_layers=2,
batch=batch_size) # 模型预测
prediction = tf.nn.softmax(loss) # 输出概率向量
saver = tf.train.Saver(tf.global_variables())
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
with tf.Session() as sess:
sess.run(init_op)
checkpoint = tf.train.latest_checkpoint(models)
saver.restore(sess, checkpoint) # 加载模型
x = np.array([list(map(word_dic.get, 'B'))]) # 得到首字符的字典对应数字
[predict, last_state_] = sess.run([prediction, last_state],
feed_dict={input_data: x})
begin_word_ = to_word(predict, words) # 得到诗文首字
word = begin_word or begin_word_ # 首字由用户输入或系统生成
poem_ = ''
i = 0
while word != 'E': # 当预测出的字为尾字符时，停止预测
poem_ += word
i += 1
if i > m: # 预测出的字数超出诗的范围时，停止预测
break
x = np.array([[word_dic[word]]]) # 将汉字数字化，作为测试集
[predict, last_state_] = sess.run([prediction, last_state],
feed_dict={
input_data: x,
initial_state: last_state_
})
word = to_word(predict, words)
return poem_
def generate_sample(config: ml_collections.ConfigDict, workdir: str):
"""Loads the latest model in `workdir` and samples a batch of images."""
batch_size = config.sample_batch_size
rng = random.PRNGKey(config.sample_rng_seed)
rng, model_rng = random.split(rng)
rng, dropout_rng = random.split(rng)
# Create a model with dummy parameters and a dummy optimizer.
init_batch = jnp.zeros((1, 32, 32, 3))
params = train.model(config).init(
{
'params': model_rng,
'dropout': dropout_rng
}, init_batch)['params']
optimizer_def = optim.Adam(learning_rate=config.learning_rate,
beta1=0.95,
beta2=0.9995)
optimizer = optimizer_def.create(params)
_, params = train.restore_checkpoint(workdir, optimizer, params)
# Initialize batch of images
device_count = jax.local_device_count()
assert not batch_size % device_count, (
'Sampling batch size must be a multiple of the device count, got '
'sample_batch_size={}, device_count={}.'.format(
batch_size, device_count))
sample_prev = jnp.zeros(
(device_count, batch_size // device_count, 32, 32, 3))
# and batch of rng keys
sample_rng = random.split(rng, device_count)
# Generate sample using fixed-point iteration
sample = sample_iteration(config, sample_rng, params, sample_prev)
while jnp.any(sample != sample_prev):
sample_prev, sample = sample, sample_iteration(config, sample_rng,
params, sample)
return jnp.reshape(sample, (batch_size, 32, 32, 3))
if __name__ == "__main__":
#test_data_path = './dataset/test_data.txt'
#model_path = './model.pt'
#test_data_path = './dataset/test_data_41.txt'#41维数据集测试
#model_path = './model_41.pt'
test_data_path = './dataset/test_data_10_bin.txt' #5维数据集测试
model_path = './model_10_bin.pt'
test_data = Mydata(test_data_path)
test_loader = DataLoader(test_data, batch_size=64, shuffle=True)
model.load_state_dict(torch.load(model_path))
with torch.no_grad(): #进行测试
correct = 0
total = 0
for features, labels in test_loader:
#print(type(features))
features = np.array(features).astype(float).T
features = torch.Tensor(features)
labels = np.array(labels).astype(float)
labels = torch.LongTensor(labels)
output = model(features)
#print(output)
_, predicted = torch.max(output, 1)
#print(labels)
#print(labels.size())
total += labels.size(0) #获取总的样本数
#print("label" ,labels.shape)
#print("predicted ",predicted.shape)
correct += (predicted == labels).sum().item()
print("2分类10维测试集准确率:{:.2f}".format(100 * correct / total))
def main(args):
inv_fold = [1, 0][args.fold]
x, y, w = build_dataset(os.path.join(args.workdir,
'fold{}.root'.format(inv_fold)),
cfg.ml_classes,
inv_fold,
make_categorical=False,
use_class_weights=True)
preproc = pickle.load(
open(
os.path.join(args.workdir,
'preproc_fold{}.pickle'.format(args.fold)), 'rb'))
x_preproc = preproc.transform(x)
x_ph = tf.placeholder(tf.float32)
_, f = model(x_ph, len(cfg.ml_variables), len(cfg.ml_classes), args.fold)
path = tf.train.latest_checkpoint(
os.path.join(args.workdir, 'model_fold{}'.format(args.fold)))
logger.debug('Load model {}'.format(path))
config = tf.ConfigProto(intra_op_parallelism_threads=12,
inter_op_parallelism_threads=12)
session = tf.Session(config=config)
saver = tf.train.Saver()
saver.restore(session, path)
# 1D coeffs
grad1d_ops = []
for i in range(len(cfg.ml_classes)):
grad1d_ops.append(tf.gradients(f[:, i], x_ph)[0])
grads1d = session.run(grad1d_ops, feed_dict={x_ph: x_preproc})
grad_matrix = np.zeros((len(cfg.ml_classes), len(cfg.ml_variables)),
dtype=np.float32)
for i, g in enumerate(grads1d):
grad_matrix[i, :] = np.mean(np.abs(g), axis=0)
plot1d(grad_matrix, 'plain')
grad_matrix_norm = grad_matrix.copy()
for i in range(grad_matrix.shape[0]):
grad_matrix_norm[i, :] = grad_matrix_norm[i, :] / np.sum(
grad_matrix_norm[i, :])
plot1d(grad_matrix_norm, 'normrows')
# 2D coeffs
grad2d_ops = []
for i in range(len(cfg.ml_classes)):
tmp = []
for j in range(len(cfg.ml_variables)):
tmp.append(
tf.reduce_mean(tf.abs(
tf.gradients(grad1d_ops[i][:, j], x_ph)[0]),
axis=0))
grad2d_ops.append(tmp)
grads2d = session.run(grad2d_ops, feed_dict={x_ph: x_preproc})
for i, name in enumerate(cfg.ml_classes):
grad2d_matrix = np.vstack(grads2d[i])
for j in range(grad2d_matrix.shape[0]):
grad2d_matrix[
j, j] = grad2d_matrix[j, j] * 0.5 # see 2D Taylor expansion
plot2d(grad2d_matrix, name, 'plain')
grad2d_matrix = grad2d_matrix / np.sum(grad2d_matrix)
plot2d(grad2d_matrix, name, 'normed')
def __init__(self):
self.output = model()
self.sess = tf.InteractiveSession()
map2 = map2.resize((640, 240), PIL.Image.ANTIALIAS)
map3 = map3.resize((640, 240), PIL.Image.ANTIALIAS)
mask = mask.resize((640, 240), PIL.Image.ANTIALIAS)
final.paste(img, (0, 0, 640, 240))
final.paste(map0, (0, 240, 640, 480))
final.paste(map1, (0, 480, 640, 720))
final.paste(map2, (0, 720, 640, 960))
final.paste(map3, (0, 960, 640, 1200))
final.paste(mask, (0, 1200, 640, 1440))
images.append(final)
inp = Image.open(sys.argv[1])
model = model(True, (120, 320, 3), tr_model=sys.argv[2])
inp = inp.resize((320, 120))
font = ImageFont.truetype("/System/Library/Fonts/SFNSText.ttf", 16)
aimage = img_to_array(inp)
aimage = aimage.astype(np.float32) / 255
aimage = aimage - 0.5
res = model.predict(np.array([aimage]))[0]
for i in range(1, 120, 4):
apply_mask(inp, i, 5, res)
img = images.pop(0)
img.save("map" + str(i) + ".jpg")
print(datetime.datetime.now() - start)
print(model_time)
"""
import base64
from flask import Flask, render_template
from io import BytesIO
from train import process_image, model
import eventlet
import eventlet.wsgi
import numpy as np
import socketio
sio = socketio.Server()
app = Flask(__name__)
target_speed = 22
shape = (100, 100, 3)
model = model(True, shape)
@sio.on('telemetry')
def telemetry(sid, data):
# The current image from the center camera of the car
img_str = data["image"]
speed = float(data["speed"])
# Set the throttle.
throttle = 1.2 - (speed / target_speed)
# read and process image
image_bytes = BytesIO(base64.b64decode(img_str))
image, _ = process_image(image_bytes, None, False)
def __getitem__(self, idx):
with torch.no_grad():
if np.random.random() < config.SAMPLING_RATIO:
anchor_file = self.paths[idx]
anchor_label = self.labels[idx]
positive_idx = np.argwhere((self.labels == anchor_label)
& (self.paths != anchor_file))
positives = self.paths[positive_idx].flatten()
positives_model_input = get_tensors(positives)
positives_embeddings = model(positives_model_input).detach()
anchor_model_input = get_tensors([anchor_file])
anchor_embedding = model(anchor_model_input)
distaps=F.pairwise_distance(anchor_embedding.repeat(len(positives_embeddings),1),\
positives_embeddings,\
2 )
harderst_p_index = torch.argmax(distaps)
hardest_positive = positives_model_input[harderst_p_index]
negatives_idx = np.argwhere(self.labels != anchor_label)
negatives = self.paths[negatives_idx].flatten()
negatives = np.random.choice(negatives, 100, replace=False)
negatives_model_input = get_tensors(negatives)
negatives_embeddings = model(negatives_model_input)
dist_nps=F.pairwise_distance(anchor_embedding.repeat(len(negatives_embeddings),1),\
negatives_embeddings,\
2 )
harderst_n_index = torch.argmin(dist_nps)
hardest_negative = negatives_model_input[harderst_n_index]
return {
"anchor": anchor_model_input.squeeze(0).to(config.DEVICE),
"positive": hardest_positive.to(config.DEVICE),
"negative": hardest_negative.to(config.DEVICE)
}
else:
anchor_file = self.paths[idx]
anchor_label = self.labels[idx]
positive_idx = np.argwhere((self.labels == anchor_label)
& (self.paths != anchor_file))
positives = self.paths[positive_idx].flatten()
positive = np.random.choice(positives)
negatives_idx = np.argwhere(self.labels != anchor_label)
negatives = self.paths[negatives_idx].flatten()
negative = np.random.choice(negatives)
anchors = np.array(Image.open(anchor_file))
positives = np.array(Image.open(positive))
negatives = np.array(Image.open(negative))
anchors = np.transpose(anchors, (2, 0, 1)) / 255.0
positives = np.transpose(positives, (2, 0, 1)) / 255.0
negatives = np.transpose(negatives, (2, 0, 1)) / 255.0
return {"anchor":torch.tensor(anchors,dtype=torch.float,device=torch.device(config.DEVICE)),\
"positive":torch.tensor(positives,dtype=torch.float,device=torch.device(config.DEVICE)),\
"negative":torch.tensor(negatives,dtype=torch.float,device=torch.device(config.DEVICE))}
import torch
from sklearn.datasets import load_digits
from random import randint
from train import model
from model import device
import matplotlib.pyplot as plt
digits = load_digits()
for _ in range(10):
with torch.no_grad():
X = torch.tensor(digits['data'], dtype=torch.float32).to(device)
Y = torch.tensor(digits['target'], dtype=torch.int64).to(device)
hypothesis = model(X)
prediction = torch.argmax(hypothesis, 1)
correct_prediction = prediction == Y
accuracy = correct_prediction.float().mean()
print('Accuracy: ', accuracy.item())
r = randint(0, X.shape[0] - 1)
X_single_data = X[r][:].float().to(device)
Y_single_data = Y[r].to(device)
print('Label: ', Y_single_data.item())
single_prediction = model(X_single_data)
print('Prediction: ', torch.argmax(single_prediction, dim=0).item())
plt.imshow(X_single_data.view(8, 8),
cmap='Greys',
interpolation='nearest')
'-detect',
type=int,
help='Turn detection module on - 1/ off - 0. Default:0',
default=0)
args = parser.parse_args()
if os.path.exists(args.st_dir):
fetch_last_img = "ls " + args.st_dir + " | tail -n1"
else:
print("Error: streaming directory %s doesn't exist" % args.st_dir)
exit(1)
auto = False
if args.model:
shape = (shapeY, shapeX, 3)
model = model(True, shape, tr_model=args.model)
auto = args.auto
err = 0
train = False
if args.train:
train = True
img_dir = "./data_sets/" + args.train + "/data/"
data_dir = "./model_data/"
if not os.path.exists(img_dir):
os.makedirs(img_dir)
# if not args.model:
# model = model(load=False, shape)
# actions = ['A', 'D', 'C', 'B']
# links = ['/fwd', '/fwd/lf', '/fwd/rt', '/rev', '/rev/lf', '/rev/rt', '/exp' + str(args.exp_time)]
import train
import numpy as np
import sys
X = np.load("data/X.npy")
Y = np.load("data/Y.npy")
params = np.load("params.npy").item()
params, costs, iters = train.model(X, Y, params, [X.shape[0], 12, 4], 0.02,
100, True, int(sys.argv[1]))
np.save("params.npy", params)
from train import MODEL_DIR, model, INPUT, LABEL, DROPOUT_RATE
# 在验证集上测试准确率
if __name__ == '__main__':
# 验证集图片文件夹地址
DATA_DIR = BUTING_PATH + r"\data"
# 验证集标注数据
VAL_CSV_PATH = BUTING_PATH + r"\data\val.csv"
LOG_PATH = BUTING_PATH + rf"\log"
LOG_CSV_PATH = LOG_PATH + rf"\val_{today()}.csv"
# 创建验证集对象
val_set = DataSet(DATA_DIR, VAL_CSV_PATH)
# 加载训练好的模型进行预测
output = model()
predict = tf.reshape(output, [-1, CATEGORY_COUNT])
max_idx_p = tf.argmax(predict, 1)
max_idx_l = tf.argmax(tf.reshape(LABEL, [-1, CATEGORY_COUNT]), 1)
accuracy = tf.reduce_mean(
tf.cast(tf.equal(max_idx_p, max_idx_l), tf.float32))
saver = tf.train.Saver()
with tf.Session() as sess:
saver.restore(sess, tf.train.latest_checkpoint(MODEL_DIR))
all_acc = 0.0
result = dict()
for img, label, image_path, category_id in val_set:
acc, pred = sess.run([accuracy, max_idx_p],
feed_dict={INPUT: [img], LABEL: [label], DROPOUT_RATE: 0.})
from flask import Flask, json, jsonify, request, render_template
from crossdomain import crossdomain
from sort_friends import *
from train import model
app = Flask(__name__)
M = model()
@app.route('/')
def hello_world():
return 'Hello, World!'
@app.route('/influence', methods=['GET'])
@crossdomain(origin='*')
def get_influence():
print(request.data)
user_id = request.args.get("userid")
results = rank_friends(user_id, M)
print(results)
return jsonify(influence_list=results)
@app.route('/sort', methods=['GET'])
@crossdomain(origin='*')
def get_influences():
userids = json.loads(request.args.get("userids"))
print(userids)
results = sort_list(userids, M)
print(results)
import joblib
import pandas as pd
import train
from sklearn.decomposition import PCA
from sklearn.preprocessing import MinMaxScaler
import csv
import numpy as np
train.model()
rf_mod = joblib.load("rf.pkl")
svm_mod = joblib.load("svm.pkl")
test_data = pd.read_csv("TestData.csv", header=None)
test_data = train.missingValueMean(test_data)
X_ttest = train.featureMat(test_data)
sc = MinMaxScaler(feature_range=(0, 1))
if len(X_ttest) > 1:
X_ttest = sc.fit_transform(X_ttest)
else:
X_ttest = sc.fit_transform(X_ttest.T)
pca = PCA(n_components=8)
pca.fit(X_ttest)
X_ttest_pca = pca.transform(X_ttest)
rf_predicted = rf_mod.predict(X_ttest)
print("Total Test cases:", len(rf_predicted))
print("RF Predicted:", rf_predicted)
parser.add_argument(
'-url',
type=str,
help='Url for connection. Default: http://10.10.10.112',
default="http://10.10.10.112")
parser.add_argument('-data_dir',
type=str,
help='Img stream directory. Default: st_data',
default="st_data")
args = parser.parse_args()
if os.path.exists(args.data_dir):
fetch_last_img = "ls " + args.data_dir + " | tail -n1"
else:
print("Error: streaming directory %s doesn't exist" % args.data_dir)
exit(1)
auto = False
if args.model:
shape = (100, 100, 3)
model = model(True, shape, args.model)
auto = True
err = 0
actions = ['A', 'D', 'C', 'B']
links = ['/fwd', '/fwd/lt', '/fwd/rt', '/rev']
# clinks = ['curl '+ args.url + el for el in links]
clinks = [args.url + el for el in links]
# curses.wrapper(drive)
drive(auto)
def test_create_model(self):
variables = train.initialized(random.PRNGKey(0), 224)
x = random.normal(random.PRNGKey(1), (8, 224, 224, 3))
y = train.model(train=False).apply(variables, x)
self.assertEqual(y.shape, (8, 1000))
help="path to directory that contains data")
parser.add_argument("fruit",
help="name of the fruit which you which to classify")
parser.add_argument("image_path",
help="path to image that you'd like to classify")
args = parser.parse_args()
# prepares the data
x_train, x_test, y_train, y_test = preprocess.prepare_data(
args.directory_path, args.fruit)
# trains the model
model = train.model(x_train,
y_train,
x_test,
y_test,
num_iterations=int(args.num_iterations),
learning_rate=float(args.learning_rate),
print_cost=False)
# loads and reads the image you want to classify
im_pix = imageio.imread(args.image_path)
im_pix = im_pix / 255.
im_pix = resize(im_pix, (100, 100), anti_aliasing=True)
im_pix = im_pix.reshape(100 * 100 * 3, 1)
prediction = train.predict(model["w"], model["b"], im_pix)
# prints out a prediction
if str(prediction[0][0]) == '1.0':
print(f"Prediction: {args.fruit}")
