Deep Learning POWER

7/18/23, 2:38 AM FX_Trading_candle_stick.
ipynb - Colaboratory
Candle Stick Classifiaction

In financial technical analysis, a candlestick pattern is a movement in prices shown graphically on a candlestick chart that some believe
can predict a particular market movement.
Candlesticks are graphical representations of price movements for a given period of time. They are commonly formed by the opening,
high, low, and closing prices of a financial instrument.
For more , check url : https://en.wikipedia.org/wiki/Candlestick_pattern
Aurthor
Name : Farshid Hossain
Github : https://github.com/farshid101
Linkedin : https://www.linkedin.com/in/farshid-hossain-b67890218/
Objective , Target , Goal and Steps
Main Objective
Candle Stick Classifiaction
The model should detect whether the image is Downside or Upside
identify the increase and decrease by seeing the image
Predict the image by building model
Target
Make an effective model so that it can predict the right image
Increase the accuracy and decrease the loss
Steps
Download the Data from github
load the image
Make a normal model
Will Use the Transfer learning
Goal
Learn new things
Be pretient and Be consistance
Learn Experiment , Experiment and Experiment
Face the mistake and error , Solving that with not destroying the laptop or keyboard
Write Code and learn Code
Downloading Data Set From Github

Getting Data set from Github .
https://colab.research.google.com/drive/1g9VV3JUXcBDEiqZBq9fS4E8lm_B8bRjt#scrollTo=bE-V8gL0-9k7&printMode=true 1/30
7/18/23, 2:38 AM FX_Trading_candle_stick.ipynb - Colaboratory
Url for the DataSet : Link

Get the Candle_stick.zip link from the GitHub
Download the Candle_stick.zip and Upload to Colab File
Unzip the Zip file

After Download the candle_stick.zip , Upload it to Colab content
Then unzip the file
!unzip /content/candle_stick.zip
Copy the path of candle_stick.zip from Colab content

Run it , And Find the folder
And find the folder name : img_candel_stick
!unzip /content/candle_stick.zip
Archive: /content/candle_stick.zip
replace img_candel_stick/Test/DOWN/Screenshot 2023-07-13 142105.png? [y]es, [n]o, [A]ll, [N]one, [r]ename:
Exploring directory
!ls img_candel_stick/
Test Train
#Train folder
!ls img_candel_stick/Train/
DOWN UP
#Test folder
!ls img_candel_stick/Test/
DOWN UP
#finding images
!ls img_candel_stick/Train/DOWN/
'Screenshot 2023-07-13 141456.png' 'Screenshot 2023-07-14 021349.png'

Screenshot 2023-07-14 020457.png Screenshot 2023-07-14 022635.png
Counting directory and image
import os
for dirpath , dir_num , file_num in os.walk("img_candel_stick"):
print(f"There are {len(dir_num)} directories and {len(file_num)} images in ' {dirpath} ' ")
There are 2 directories and 0 images in ' img_candel_stick '

There are 2 directories and 0 images in ' img_candel_stick/Test '
There are 0 directories and 36 images in ' img_candel_stick/Test/UP '
There are 0 directories and 36 images in ' img_candel_stick/Test/DOWN '
There are 2 directories and 0 images in ' img_candel_stick/Train '
There are 0 directories and 120 images in ' img_candel_stick/Train/UP '
There are 0 directories and 120 images in ' img_candel_stick/Train/DOWN '
# Another way to find out how many images are in a file
num_steak_images_train = len(os.listdir("img_candel_stick/Train/DOWN/"))
num_steak_images_train
120
Getting the class names or finding label name
# Get the class names (programmatically, this is much more helpful with a longer list of classes)
import pathlib
import numpy as np
data_dir = pathlib.Path("img_candel_stick/Train/") # turn our training path into a Python path
class_names = np.array(sorted([item.name for item in data_dir.glob('*')])) # created a list of class_names from the subdirectories
print(class_names)
['DOWN' 'UP']
Image Load
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import random
import os
def view_random_image(target_dir, target_class):
# Setup target directory (we'll view images from here)
target_folder = target_dir+target_class
# Get a random image path
random_image = random.sample(os.listdir(target_folder), 1)
# Read in the image and plot it using matplotlib
img = mpimg.imread(target_folder + "/" + random_image[0])
plt.imshow(img)
plt.title(target_class) # Changed
plt.axis("off");
print(f"Image shape: {img.shape}") # show the shape of the image
return img
Image loading of Down folder
img = view_random_image(target_dir="img_candel_stick/Train/",
target_class="DOWN")
Image shape: (312, 257, 4)
Image loading of UP folder
target_class="UP")
Image shape: (611, 498, 4)
Making a function to see random image from directory and target class
def random_view(T_target_dir , T_target_class , Te_target_dir , Te_target_class ):
plt.figure(figsize=(16,10))
for i in range(12):
ax=plt.subplot( 6 ,2 ,i+1 )
if(i%2==1):
view_random_image(T_target_dir, T_target_class)
else:
view_random_image(Te_target_dir, Te_target_class)
random_view("img_candel_stick/Train/","UP","img_candel_stick/Train/", "DOWN" )
Image shape: (517, 592, 4)

Image shape: (387, 851, 4)
Image shape: (222, 456, 4)
Image shape: (703, 1532, 4)
Image shape: (573, 737, 4)
Image shape: (667, 702, 4)
Image shape: (348, 445, 4)
Image shape: (637, 992, 4)
Image shape: (667, 1107, 4)
Image shape: (703, 1532, 4)
Image shape: (423, 1062, 4)
Image shape: (198, 178, 4)
Making Raw CNN model
1. Finding img shape
target_class="DOWN")
Image shape: (312, 345, 4)
img.shape
(312, 345, 4)
img
array([[[1., 1., 1., 1.],

[1., 1., 1., 1.],
[1., 1., 1., 1.],
...,
[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]],
[[1., 1., 1., 1.],

[1., 1., 1., 1.],
[1., 1., 1., 1.],
...,
[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]],
[[1., 1., 1., 1.],

[1., 1., 1., 1.],
[1., 1., 1., 1.],
...,
[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]],
...,
[[1., 1., 1., 1.],

[1., 1., 1., 1.],
[1., 1., 1., 1.],
...,
[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]],
[[1., 1., 1., 1.],

[1., 1., 1., 1.],
[1., 1., 1., 1.],
...,
[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]],
[[1., 1., 1., 1.],

[1., 1., 1., 1.],
[1., 1., 1., 1.],
...,
[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]]], dtype=float32)
2. Train and Split image
train_dir = "img_candel_stick/Train/"
test_dir = "img_candel_stick/Test/"
3. Making the folder prepared for the model
import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator
# Set the seed
tf.random.set_seed(42)
# Preprocess data (get all of the pixel values between 1 and 0, also called scaling/normalization)
train_datagen = ImageDataGenerator(rescale=1./255)
valid_datagen = ImageDataGenerator(rescale=1./255)
# Import data from directories and turn it into batches
train_data = train_datagen.flow_from_directory(train_dir,
batch_size=32, # number of images to process at a time
target_size=(224, 224), # convert all images to be 224 x 224
class_mode="binary", # type of problem we're working on
seed=42)
valid_data = valid_datagen.flow_from_directory(test_dir,
batch_size=32,
target_size=(224, 224),
class_mode="binary",
seed=42)
Found 240 images belonging to 2 classes.

Model_1
model_1 = tf.keras.models.Sequential([
tf.keras.layers.Conv2D(filters=10,
kernel_size=3, # can also be (3, 3)
activation="relu",
input_shape=(224, 224, 3)), # first layer specifies input shape (height, width, colour channels)
tf.keras.layers.Conv2D(10, 3, activation="relu"),
tf.keras.layers.MaxPool2D(pool_size=2, # pool_size can also be (2, 2)
padding="valid"), # padding can also be 'same'
tf.keras.layers.Conv2D(10, 3, activation="relu"), # activation='relu' == tf.keras.layers.Activations(tf.nn.relu)
tf.keras.layers.MaxPool2D(2),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(1, activation="sigmoid") # binary activation output
])
# Compile the model
model_1.compile(loss="binary_crossentropy",
optimizer=tf.keras.optimizers.Adam(),
metrics=["accuracy"])
# Fit the model
history_1 = model_1.fit(train_data,
epochs=5,
steps_per_epoch=len(train_data),
validation_data=valid_data,
validation_steps=len(valid_data))
Epoch 1/5
8/8 [==============================] - 15s 437ms/step - loss: 0.7090 - accuracy: 0.5417 - val_loss: 0.6733 - val_accuracy: 0.5000
Epoch 2/5
Epoch 3/5
Epoch 4/5
Epoch 5/5
# Check out the layers in our model
model_1.summary()
Model: "sequential"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
conv2d (Conv2D) (None, 222, 222, 10) 280
conv2d_1 (Conv2D) (None, 220, 220, 10) 910
max_pooling2d (MaxPooling2D (None, 110, 110, 10) 0

)
conv2d_2 (Conv2D) (None, 108, 108, 10) 910
conv2d_3 (Conv2D) (None, 106, 106, 10) 910
max_pooling2d_1 (MaxPooling (None, 53, 53, 10) 0

2D)
flatten (Flatten) (None, 28090) 0
dense (Dense) (None, 1) 28091
=================================================================
Total params: 31,101
Trainable params: 31,101
Non-trainable params: 0
_________________________________________________________________
4. History of model 1
# Plot the training curves
import pandas as pd
pd.DataFrame(history_1.history).plot(figsize=(10, 7));
Making a History function
# Plot the validation and training data separately
def plot_loss_curves(history):
"""
Returns separate loss curves for training and validation metrics.
"""
loss = history.history['loss']
val_loss = history.history['val_loss']
accuracy = history.history['accuracy']
val_accuracy = history.history['val_accuracy']
epochs = range(len(history.history['loss']))
# Plot loss
plt.plot(epochs, loss, label='training_loss')
plt.plot(epochs, val_loss, label='val_loss')
plt.title('Loss')
plt.xlabel('Epochs')
plt.legend()
# Plot accuracy
plt.figure()
plt.plot(epochs, accuracy, label='training_accuracy')
plt.plot(epochs, val_accuracy, label='val_accuracy')
plt.title('Accuracy')
plt.xlabel('Epochs')
plt.legend();
plot_loss_curves(history_1)
Improving Model with Data augmentation
# Create ImageDataGenerator training instance with data augmentation
train_datagen_augmented = ImageDataGenerator(rescale=1/255.,
rotation_range=20, # rotate the image slightly between 0 and 20 degrees (note: this is an in
shear_range=0.2, # shear the image
zoom_range=0.2, # zoom into the image
width_shift_range=0.2, # shift the image width ways
height_shift_range=0.2, # shift the image height ways
horizontal_flip=True) # flip the image on the horizontal axis
# Create ImageDataGenerator training instance without data augmentation
train_datagen = ImageDataGenerator(rescale=1/255.)
# Create ImageDataGenerator test instance without data augmentation
test_datagen = ImageDataGenerator(rescale=1/255.)
Here Shuffle is false
# Import data and augment it from training directory
print("Augmented training images:")
train_data_augmented = train_datagen_augmented.flow_from_directory(train_dir,
batch_size=32,
class_mode='binary',
shuffle=False) # Don't shuffle for demonstration purposes, usually a g
# Create non-augmented data batches
print("Non-augmented training images:")
batch_size=32,
shuffle=False) # Don't shuffle for demonstration purposes
print("Unchanged test images:")
test_data = test_datagen.flow_from_directory(test_dir,
batch_size=32,
class_mode='binary')
Augmented training images:

Non-augmented training images:
Unchanged test images:
Get data batch samples
images, labels = train_data.next()
augmented_images, augmented_labels = train_data_augmented.next()
Show original image and augmented image
# Show original image and augmented image
random_number = random.randint(0, 32) # we're making batches of size 32, so we'll get a random instance
plt.imshow(images[random_number])
plt.title(f"Original image")
plt.axis(False)
plt.figure()
plt.imshow(augmented_images[random_number])
plt.title(f"Augmented image")
plt.axis(False);
Making new model for data augmentation
Model_2
# Creating model
model_2= tf.keras.models.Sequential([
tf.keras.layers.Conv2D(10 ,3, activation="relu" , input_shape=(224, 224, 3)) ,
tf.keras.layers.MaxPool2D(pool_size=2) ,# reduce number of features by half
tf.keras.layers.Conv2D(10 ,3, activation="relu" ) ,
tf.keras.layers.MaxPool2D() ,
tf.keras.layers.Flatten() ,
tf.keras.layers.Dense(1, activation='sigmoid')
])
# Compile the model
model_2.compile(loss='binary_crossentropy',
metrics=['accuracy'])
# Fit the model
history_2 = model_2.fit(train_data_augmented, # changed to augmented training data
epochs=5,
steps_per_epoch=len(train_data_augmented),
validation_data=test_data,
validation_steps=len(test_data))
Epoch 1/5
Epoch 2/5
Epoch 3/5
Epoch 4/5
Epoch 5/5
History of model 2 and shuffle is fales
Tring to Improve the model 2 by shuffel ture
# Import data and augment it from directories
train_data_augmented_shuffled = train_datagen_augmented.flow_from_directory(train_dir,
batch_size=32,
shuffle=True) # Shuffle data (default)
Model_3 shuffel true
# Creating model
model_3= tf.keras.models.Sequential([
tf.keras.layers.Conv2D(10 ,3, activation="relu" , input_shape=(224, 224, 3)) ,
tf.keras.layers.MaxPool2D(pool_size=2) ,# reduce number of features by half
tf.keras.layers.Flatten() ,
tf.keras.layers.Dense(1, activation='sigmoid')
])
# Compile the model
model_3.compile(loss='binary_crossentropy',
# Fit the model
history_3 = model_3.fit(train_data_augmented_shuffled, # changed to augmented training data
epochs=5,
steps_per_epoch=len(train_data_augmented),
validation_steps=len(test_data))
Epoch 1/5
Epoch 2/5
Epoch 3/5
Epoch 4/5
Epoch 5/5
History of model 3
Making a comparing history function
import matplotlib.pyplot as plt
def plot_compare_history(histories):
"""
Plots separate loss curves for training and validation metrics for multiple histories.
"""
colors = ['b', 'g', 'r', 'c', 'm', 'y', 'k'] # Define colors for each history
# Create subplots
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 6))
for i, history in enumerate(histories):
loss = history.history['loss']
val_loss = history.history['val_loss']
accuracy = history.history['accuracy']
val_accuracy = history.history['val_accuracy']
epochs = range(len(history.history['loss']))
# Plot loss
ax1.plot(epochs, loss, label=f'Training Loss {i+1}', color=colors[i])
ax1.plot(epochs, val_loss, label=f'Validation Loss {i+1}', linestyle='--', color=colors[i])
ax1.set_title('Loss')
ax1.set_xlabel('Epochs')
ax1.legend()
# Plot accuracy
ax2.plot(epochs, accuracy, label=f'Training Accuracy {i+1}', color=colors[i])
ax2.plot(epochs, val_accuracy, label=f'Validation Accuracy {i+1}', linestyle='--', color=colors[i])
ax2.set_title('Accuracy')
ax2.set_xlabel('Epochs')
ax2.legend()
# Display the plot
plt.tight_layout()
plt.show()
History Compare info part 1

Info
History 2 is Model 2 and Shuffle is False
History 3 is Model 3 and Shuffle is True
histories = [ history_2, history_3]
plot_compare_history(histories)
History Compare info part 2

Info
History 1 is Model 1
History 3 is Model 3 and Shuffle is True
histories = [ history_1, history_3]
Report 1
Without Data augmentation the model is doing well .
Both shuffle ture or false model is performing Not Good ( model 2 , model_3 )
Improving model_1 by making a new one and increasing the epoch layers, learning rate
number
Model_4 ( Increasing epochs number )

`
activation="relu",
])
# Compile the model
# Fit the model
history_4_e = model_4.fit(train_data,
epochs=10,
Epoch 1/10
Epoch 2/10
Epoch 3/10
Epoch 4/10
Epoch 5/10
Epoch 6/10
Epoch 7/10
Epoch 8/10
Epoch 9/10
Epoch 10/10
Model_4 ( Increasing layers number )
activation="relu",
])
# Compile the model
# Fit the model
history_4_l = model_4.fit(train_data,
epochs=5,
Epoch 1/5
Epoch 2/5
Epoch 3/5
Epoch 4/5
Epoch 5/5
Model_4 ( Increasing learing rate )
activation="relu",
])
# Compile the model
optimizer=tf.keras.optimizers.Adam(lr=0.001), # Default , learning_rate: float = 0.001
# Fit the model
history_4_lr = model_4.fit(train_data,
epochs=5,
WARNING:absl:`lr` is deprecated in Keras optimizer, please use `learning_rate` or use the legacy optimizer, e.g.,tf.keras.optimizer
Epoch 1/5
Epoch 2/5
Epoch 3/5
Epoch 4/5
Epoch 5/5
Comparing model 4
( Here , Model_1 was chosen for the experiment )
history_4_e is Model 4 and epochs was increased from 5 to 10

history_4_l is Model 4 and layer was increased from 8 to 19
history_4_lr is Model 4 and Learning rate was increased from 0.001 to 0.001
histories = [ history_4_e, history_4_l ,history_4_lr]
Report 2
Model 1's epochs, layers, and learning rate were increased
Model 1 performance may be improved by increasing epochs and learning rate.
Creating a new model based on model 4's knowledge
Model_5
increasing the number of layers, epochs, and learning rate
activation="relu",
])
# Compile the model
optimizer=tf.keras.optimizers.Adam(lr=0.0003),
# Fit the model
epochs=15,
Epoch 1/15
Epoch 2/15
Epoch 3/15
Epoch 4/15
Epoch 5/15
Epoch 6/15
Epoch 7/15
Epoch 8/15
Epoch 9/15
Epoch 10/15
Epoch 11/15
Epoch 12/15
Epoch 13/15
Epoch 14/15
Epoch 15/15
History of Model 5
Report 3
Model 5 was Great
But the validation loss is abnormanl
train loss and validation loss has a big difference
Creating a new model based on model 5's knowledge
Model_6
activation="relu",
])
# Compile the model
optimizer=tf.keras.optimizers.Adam(lr=0.0001),
# Fit the model
epochs=25,
Epoch 1/25
Epoch 2/25
Epoch 3/25
Epoch 4/25
Epoch 5/25
Epoch 6/25
Epoch 7/25
Epoch 8/25
Epoch 9/25
Epoch 10/25
Epoch 11/25
Epoch 12/25
Epoch 13/25
Epoch 14/25
Epoch 15/25
Epoch 16/25
Epoch 17/25
Epoch 18/25
Epoch 19/25
Epoch 20/25
Epoch 21/25
Epoch 22/25
8/8 [==============================] - 2s 228ms/step - loss: 6.0399e-04 - accuracy: 1.0000 - val_loss: 1.0580 - val_accuracy: 0.930
Epoch 23/25
Epoch 24/25
Epoch 25/25
History of Model 6
Prediction
Load and prepared image function
def load_and_prep_image(filename, img_shape=224):
"""
Reads an image from filename, turns it into a tensor
and reshapes it to (img_shape, img_shape, colour_channel).
"""
# Read in target file (an image)
img = tf.io.read_file(filename)
# Decode the read file into a tensor & ensure 3 colour channels
# (our model is trained on images with 3 colour channels and sometimes images have 4 colour channels)
img = tf.image.decode_image(img, channels=3)
# Resize the image (to the same size our model was trained on)
img = tf.image.resize(img, size = [img_shape, img_shape])
# Rescale the image (get all values between 0 and 1)
img = img/255.
return img
Model and file show function for prediction
def pred_and_plot(model, filename, class_names):
"""
Imports an image located at filename, makes a prediction on it with
a trained model and plots the image with the predicted class as the title.
"""
# Import the target image and preprocess it
img = load_and_prep_image(filename)
# Make a prediction
pred = model.predict(tf.expand_dims(img, axis=0))
# Get the predicted class
pred_class = class_names[int(tf.round(pred)[0][0])]
# Plot the image and predicted class
plt.imshow(img)
plt.title(f"Prediction: {pred_class}")
plt.axis(False);
This image was collected randomly from , Tradingview.com . image : Screenshot 2023-07-17 153241.png
Url of image : https://github.com/farshid101/Real-life-Exclusive-Deep-learning-
project/blob/main/FX%20Trading/test_iamge/Screenshot%202023-07-17%20153241.png
All the image can find here : https://github.com/farshid101/Real-life-Exclusive-Deep-learning-project/tree/main/FX%20Trading/test_iamge
pred_and_plot(model_6, "Screenshot 2023-07-17 153241.png", class_names)
1/1 [==============================] - 0s 364ms/step
Getting image from Github

url : https://github.com/farshid101/Real-life-Exclusive-Deep-learning-
project/blob/main/FX%20Trading/test_iamge/test%20image%20.png
!wget https://github.com/farshid101/Real-life-Exclusive-Deep-learning-project/blob/main/FX%20Trading/test_iamge/test%20image%20.png
--2023-07-17 18:53:46-- https://github.com/farshid101/Real-life-Exclusive-Deep-learning-project/blob/main/FX%20Trading/test_iamge/

Resolving github.com (github.com)... 20.205.243.166
Connecting to github.com (github.com)|20.205.243.166|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 5403 (5.3K) [text/plain]
Saving to: ‘test image .png.1’
test image .png.1 100%[===================>] 5.28K --.-KB/s in 0s
2023-07-17 18:53:46 (65.4 MB/s) - ‘test image .png.1’ saved [5403/5403]
Predicting the image
1/1 [==============================] - 0s 18ms/step
1/1 [==============================] - 0s 19ms/step
Download the model_6

Here , You can find all the models . URL :https://github.com/farshid101/Real-life-Exclusive-Deep-learning-
project/tree/main/FX%20Trading/Models
Saving Model
model_6.save('Raw_model.h5')
Loading model
# Load the saved model
model = load_model('Raw_model.h5')
# Use the loaded model for predictions
pred_and_plot(model, "Screenshot 2023-07-17 182350.png", class_names)
1/1 [==============================] - 0s 87ms/step
Transfer learning in Tensorflow
Checking GPU
# Are we using a GPU?
!nvidia-smi
Mon Jul 17 19:31:27 2023

+-----------------------------------------------------------------------------+
| NVIDIA-SMI 525.105.17 Driver Version: 525.105.17 CUDA Version: 12.0 |
|-------------------------------+----------------------+----------------------+
| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |
| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |
| | | MIG M. |
|===============================+======================+======================|
| 0 Tesla T4 Off | 00000000:00:04.0 Off | 0 |
| N/A 65C P0 28W / 70W | 5005MiB / 15360MiB | 0% Default |
| | | N/A |
+-------------------------------+----------------------+----------------------+
+-----------------------------------------------------------------------------+
| Processes: |
| GPU GI CI PID Type Process name GPU Memory |
| ID ID Usage |
|=============================================================================|
+-----------------------------------------------------------------------------+
Create tensorboard callback
import datetime
def create_tensorboard_callback(dir_name, experiment_name):
log_dir = dir_name + "/" + experiment_name + "/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = tf.keras.callbacks.TensorBoard(
log_dir=log_dir
)
print(f"Saving TensorBoard log files to: {log_dir}")
return tensorboard_callback
Creating models using TensorFlow Hub

In the past we've used TensorFlow to create our own models layer by layer from scratch.
Now we're going to do a similar process, except the majority of our model's layers are going to come from TensorFlow Hub.
1. ResNetV2 - a state of the art computer vision model architecture from 2016.
2. EfficientNet - a state of the art computer vision architecture from 2019.
import TensorFlow and TensorFlow Hub.
import tensorflow as tf
import tensorflow_hub as hub
from tensorflow.keras import layers
Models url
# Resnet 50 V2 feature vector
resnet_url = "https://tfhub.dev/google/imagenet/resnet_v2_50/feature_vector/4"
# Original: EfficientNetB0 feature vector (version 1)
efficientnet_url = "https://tfhub.dev/tensorflow/efficientnet/b0/feature-vector/1"
Creating model function
# Setup data inputs
from tensorflow.keras.preprocessing.image import ImageDataGenerator
IMAGE_SHAPE = (224, 224)
BATCH_SIZE = 32
train_datagen = ImageDataGenerator(rescale=1/255.)
test_datagen = ImageDataGenerator(rescale=1/255.)
print("Training images:")
target_size=IMAGE_SHAPE,
batch_size=BATCH_SIZE,
class_mode="binary")
print("Testing images:")
test_data = train_datagen.flow_from_directory(test_dir,
target_size=IMAGE_SHAPE,
batch_size=BATCH_SIZE,
class_mode="binary")

Training images:
Testing images:
def create_model(model_url, num_classes=10):
"""Takes a TensorFlow Hub URL and creates a Keras Sequential model with it.

Args:
model_url (str): A TensorFlow Hub feature extraction URL.
num_classes (int): Number of output neurons in output layer,
should be equal to number of target classes, default 10.
Returns:
An uncompiled Keras Sequential model with model_url as feature
extractor layer and Dense output layer with num_classes outputs.
"""
# Download the pretrained model and save it as a Keras layer
feature_extractor_layer = hub.KerasLayer(model_url,
trainable=False, # freeze the underlying patterns
name='feature_extraction_layer',
input_shape=IMAGE_SHAPE+(3,)) # define the input image shape

# Create our own model
model = tf.keras.Sequential([
feature_extractor_layer, # use the feature extraction layer as the base
layers.Dense(num_classes, activation='sigmoid', name='output_layer') # create our own output layer
])
return model
Resnet_model
# Create model
resnet_model = create_model(resnet_url, num_classes=1)
# Compile
resnet_model.compile(loss='binary_crossentropy',
Fit the model
# Fit the model
resnet_history = resnet_model.fit(train_data,
epochs=10,
validation_steps=len(test_data),
# Add TensorBoard callback to model (callbacks parameter takes a list)
callbacks=[create_tensorboard_callback(dir_name="tensorflow_hub", # save experiment logs here
experiment_name="resnet50V2")]) # name of log
Saving TensorBoard log files to: tensorflow_hub/resnet50V2/20230717-195807

Epoch 1/10
Epoch 2/10
Epoch 3/10
Epoch 4/10
Epoch 5/10
Epoch 6/10
Epoch 7/10
Epoch 8/10
Epoch 9/10
Epoch 10/10
Predict of Resnet_model
pred_and_plot( resnet_model, "Screenshot 2023-07-17 153241.png", class_names)
1/1 [==============================] - 0s 84ms/step
Resnet_history
histories = [ resnet_history]
Improving model by increasing epochs
# Fit the model
resnet_history_epochs = resnet_model.fit(train_data,
epochs=25,
validation_steps=len(test_data),
# Add TensorBoard callback to model (callbacks parameter takes a list)
callbacks=[create_tensorboard_callback(dir_name="tensorflow_hub", # save experiment logs here
experiment_name="resnet50V2")]) # name of log
Saving TensorBoard log files to: tensorflow_hub/resnet50V2/20230717-200654

Epoch 1/25
Epoch 2/25
Epoch 3/25
Epoch 4/25
Epoch 5/25
Epoch 6/25
Epoch 7/25
Epoch 8/25
Epoch 9/25
Epoch 10/25
Epoch 11/25
Epoch 12/25
Epoch 13/25
Epoch 14/25
Epoch 15/25
Epoch 16/25
Epoch 17/25
Epoch 18/25
Epoch 19/25
Epoch 20/25
Epoch 21/25
Epoch 22/25
Epoch 23/25
Epoch 24/25
Epoch 25/25
Download
resnet_model.save('resnet_model_25_epochs.h5')
histories = [ resnet_history_epochs ]
Prediction of model
pred_and_plot( resnet_model, "Screenshot 2023-07-18 021441.png", class_names)
1/1 [==============================] - 0s 26ms/step
pred_and_plot( resnet_model, "test.png", class_names)
1/1 [==============================] - 0s 118ms/step
pred_and_plot( resnet_model, "1111.png", class_names)
1/1 [==============================] - 0s 44ms/step
pred_and_plot( resnet_model, "2222.png", class_names)
1/1 [==============================] - 0s 22ms/step
Aurthor
Name : Farshid Hossain
Github : https://github.com/farshid101
Linkedin : https://www.linkedin.com/in/farshid-hossain-b67890218/
check 0s completed at 2:28 AM

Deep Learning POWER

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Deep Learning POWER

Uploaded by

Copyright:

Available Formats

7/18/23, 2:38 AM FX_Trading_candle_stick.

Candle Stick Classifiaction

For more , check url : https://en.wikipedia.org/wiki/Candlestick_pattern

Objective , Target , Goal and Steps

Downloading Data Set From Github

Url for the DataSet : Link

Unzip the Zip file

Copy the path of candle_stick.zip from Colab content

'Screenshot 2023-07-13 141456.png' 'Screenshot 2023-07-14 021349.png'

Counting directory and image

There are 2 directories and 0 images in ' img_candel_stick '

Getting the class names or finding label name

Image loading of Down folder

Image shape: (312, 257, 4)

Image loading of UP folder

Image shape: (611, 498, 4)

Image shape: (517, 592, 4)

Making Raw CNN model

1. Finding img shape

Image shape: (312, 345, 4)

array([[[1., 1., 1., 1.],

[[1., 1., 1., 1.],

[[1., 1., 1., 1.],

[[1., 1., 1., 1.],

[[1., 1., 1., 1.],

[[1., 1., 1., 1.],

2. Train and Split image

3. Making the folder prepared for the model

Found 240 images belonging to 2 classes.

conv2d_1 (Conv2D) (None, 220, 220, 10) 910

max_pooling2d (MaxPooling2D (None, 110, 110, 10) 0

conv2d_2 (Conv2D) (None, 108, 108, 10) 910

max_pooling2d_1 (MaxPooling (None, 53, 53, 10) 0

flatten (Flatten) (None, 28090) 0

dense (Dense) (None, 1) 28091

Making a History function

Improving Model with Data augmentation

Here Shuffle is false

Augmented training images:

Get data batch samples

Show original image and augmented image

Making new model for data augmentation

History of model 2 and shuffle is fales

Tring to Improve the model 2 by shuffel ture

Found 240 images belonging to 2 classes.

Model_3 shuffel true

Making a comparing history function

History Compare info part 1

History Compare info part 2

Model_4 ( Increasing epochs number )

Model_4 ( Increasing layers number )

Model_4 ( Increasing learing rate )

history_4_e is Model 4 and epochs was increased from 5 to 10

Creating a new model based on model 4's knowledge

Creating a new model based on model 5's knowledge

Load and prepared image function

Model and file show function for prediction

All the image can find here : https://github.com/farshid101/Real-life-Exclusive-Deep-learning-project/tree/main/FX%20Trading/test_iamge

1/1 [==============================] - 0s 364ms/step

Getting image from Github

--2023-07-17 18:53:46-- https://github.com/farshid101/Real-life-Exclusive-Deep-learning-project/blob/main/FX%20Trading/test_iamge/

test image .png.1 100%[===================>] 5.28K --.-KB/s in 0s

2023-07-17 18:53:46 (65.4 MB/s) - ‘test image .png.1’ saved [5403/5403]

check 0s completed at 2:28 AM