basic-lstm 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 77cfe659ce2d038f9f415fee83f260f7b7923933fa9275536f490066f26c96af
+  data.tar.gz: d5f35dd0a7625c278f9c17230e5fa7b31f8495405d22302786ef7f831877c692
+SHA512:
+  metadata.gz: 2c854837f63551d21cde6a45d57855cda75a1b8b8e4db14d51ce540bbc24e127995793046385c56e9e05a9adaf12b7b2fce1fc05994d90007f39409c9056dd65
+  data.tar.gz: 57d4f463984171afd4a90d267d430b5226c649edcc08104634c4ab803d46cf8fd5c2428653c888ad3ab6d8724eba646bfec4c118c3bea2e0f64a240ff673db4f

data/lib/CELL.rb

@@ -0,0 +1,261 @@
+#!/usr/bin/env ruby
+=begin
+██╗░░░░░░██████╗████████╗███╗░░░███╗
+██║░░░░░██╔════╝╚══██╔══╝████╗░████║
+██║░░░░░╚█████╗░░░░██║░░░██╔████╔██║
+██║░░░░░░╚═══██╗░░░██║░░░██║╚██╔╝██║
+███████╗██████╔╝░░░██║░░░██║░╚═╝░██║
+╚══════╝╚═════╝░░░░╚═╝░░░╚═╝░░░░░╚═╝
+Created: 	14/09/2023.
+Version: 	1.0.0
+Author: 	Ryan May
+This is a text generator LSTM developed in Ruby. 
+In this project I gain more of an understanding of the training and creation of LSTM networks.
+This LSTM network utilises the Numo::Narray library to calculate cell states and the cell network.
+Expansion on this project will be utilised in my Honours project. 
+=end
+require 'matrix' 		# https://www.rubyguides.com/2019/01/ruby-matrix/
+require 'numo/narray'
+include Numo
+=begin 
+██╗░░░░░░██████╗████████╗███╗░░░███╗ ░█████╗░███████╗██╗░░░░░██╗░░░░░
+██║░░░░░██╔════╝╚══██╔══╝████╗░████║ ██╔══██╗██╔════╝██║░░░░░██║░░░░░
+██║░░░░░╚█████╗░░░░██║░░░██╔████╔██║ ██║░░╚═╝█████╗░░██║░░░░░██║░░░░░
+██║░░░░░░╚═══██╗░░░██║░░░██║╚██╔╝██║ ██║░░██╗██╔══╝░░██║░░░░░██║░░░░░
+███████╗██████╔╝░░░██║░░░██║░╚═╝░██║ ╚█████╔╝███████╗███████╗███████╗
+╚══════╝╚═════╝░░░░╚═╝░░░╚═╝░░░░░╚═╝ ░╚════╝░╚══════╝╚══════╝╚══════╝
+=end
+class LSTM_CELL
+	# Constructor
+    # This initialisation function configures the LSTM Cell by
+	# constructing the required arrays (Numo::NArrays)
+	def init(alpha, sz, terminal_output=nil)
+		@sz = sz
+		@@Alpha = alpha
+		### Weight matrices with regard to inputs
+		@Wg = DFloat.new(1, @sz).rand
+		@Wi = DFloat.new(1, @sz).rand
+		@Wf = DFloat.new(1, @sz).rand
+		@Wo = DFloat.new(1, @sz).rand
+		### Weight matrices with regard to cell previous cell output
+		@Ug = DFloat.new(1, @sz).rand
+		@Ui = DFloat.new(1, @sz).rand
+		@Uf = DFloat.new(1, @sz).rand
+		@Uo = DFloat.new(1, @sz).rand
+		### Bias
+		@Bg = DFloat.new(1, @sz).rand
+		@Bi = DFloat.new(1, @sz).rand
+		@Bf = DFloat.new(1, @sz).rand
+		@Bo = DFloat.new(1, @sz).rand
+		### Cell input
+		@Xt = DFloat.zeros(1, @sz)
+		@Yt = DFloat.zeros(1, @sz)
+		### Cell state
+		@Hprev 	= DFloat.zeros(1, @sz) # Previous cell output
+		@Cprev  = DFloat.zeros(1, @sz) # Previous cell state
+		@Ct 	= DFloat.zeros(1, @sz) # Cell state
+		@Ht 	= DFloat.zeros(1, @sz) # Cell output		
+		### Internal Cell gates
+		@F = DFloat.new(1, @sz).rand
+		@I = DFloat.new(1, @sz).rand
+		@O = DFloat.new(1, @sz).rand
+		@G = DFloat.new(1, @sz).rand
+		### BPTT variables 
+		### Change related to cell input
+		@dWi = DFloat.zeros(1, @sz)
+		@dWf = DFloat.zeros(1, @sz)
+		@dWo = DFloat.zeros(1, @sz)
+		@dWg = DFloat.zeros(1, @sz)
+		### Change related to cell state
+		@dUi = DFloat.zeros(1, @sz)
+		@dUf = DFloat.zeros(1, @sz)
+		@dUo = DFloat.zeros(1, @sz)
+		@dUg = DFloat.zeros(1, @sz)
+		### Change required to Bias 
+		@dBi = DFloat.zeros(1, @sz)
+		@dBf = DFloat.zeros(1, @sz)
+		@dBo = DFloat.zeros(1, @sz)
+		@dBg = DFloat.zeros(1, @sz)
+	end
+	# Hadamard product 
+	def hp(nArr1, nArr2)
+		nArr3 = DFloat.zeros(nArr1.shape())
+		dims = nArr1.shape()
+		for i in 0...(dims[0])
+			for j in 0...(dims[1])
+				nArr3[i,j] = (nArr1[i,j] * nArr2[i,j])
+			end
+		end
+		return nArr3
+	end
+	# Forward Propagation
+	def forwardPropagation()
+		### Calculating gate values
+		@Zf = @Wf.dot(@Xt) + @Uf.dot(@Hprev) + @Bf
+		@F = sigmoidVector(@Zf)
+		@Zi = @Wi.dot(@Xt) + @Ui.dot(@Hprev) + @Bi
+		@I = sigmoidVector(@Zi)
+		@Zo = @Wo.dot(@Xt) + @Uo.dot(@Hprev) + @Bo
+		@O = sigmoidVector(@Zo)
+		@Zg = @Wg.dot(@Xt) + @Ug.dot(@Hprev) + @Bg
+		@G = NMath.tanh(@Zg)  
+		### Calculating cell states 
+		@Ct = hp(@F, @Cprev) + hp(@I, @G)
+		@Ht = hp(@O,  NMath.tanh(@Ct))
+	end
+	# Back propagation
+	def backwardPropagation(top_diff_h, top_diff_c)
+		dC = hp(@O, top_diff_h) + top_diff_c
+		dO = hp(@Ct, top_diff_h)
+		dI = hp(@G, dC)
+		dG = hp(@I, dC)
+		dF = hp(@Cprev, dC)
+		
+		dIinput = hp(sigmoidDer(@I), dI)
+		dFinput = hp(sigmoidDer(@F), dF)
+		dOinput = hp(sigmoidDer(@O), dO)
+		dGinput = hp(tanhDer(@G), dG)
+		### Calculating change required to input weight matrices
+		@dWi -= hp(dIinput, @Xt)
+		@dWf -= hp(dFinput, @Xt)
+		@dWo -= hp(dOinput, @Xt)
+		@dWg -= hp(dGinput, @Xt)
+		#p @dWi.to_a
+		### Calculating change required to cell state weight matrices
+		@dUi += hp(dIinput, @Hprev)
+		@dUf += hp(dFinput, @Hprev)
+		@dUo += hp(dOinput, @Hprev)
+		@dUg += hp(dGinput, @Hprev)
+		### Calculating change required to bias vectors
+		@dBi += dIinput
+		@dBf += dFinput
+		@dBo += dOinput
+		@dBg += dGinput
+		### Calculating change required to HPrev
+		dHprev = DFloat.zeros(1, @sz)
+		dHprev += @Wi.transpose.dot(dIinput)
+		dHprev += @Wf.transpose.dot(dFinput)
+		dHprev += @Wo.transpose.dot(dOinput)
+		dHprev += @Wg.transpose.dot(dGinput)
+		### Calculating and returning bottoms
+		@bottom_diff_c = hp(dC, @F)
+		@bottom_diff_h = dHprev 
+	end
+	def applyWeightChange()
+		#puts ">> " + @dWg[0,0].to_s
+		### Apply input weight changes
+		@Wi += @@Alpha * @dWi #@@Alpha
+		@Wf += @@Alpha * @dWf
+		@Wo += @@Alpha * @dWo
+		@Wg += @@Alpha * @dWg
+		### Apply Cell output weight changes
+		@Ui += @@Alpha * @dUi
+		@Uf += @@Alpha * @dUf
+		@Uo += @@Alpha * @dUo
+		@Ug += @@Alpha * @dUg
+		### Apply bias changes
+		@Bi += @@Alpha * @dBi
+		@Bf += @@Alpha * @dBf
+		@Bo += @@Alpha * @dBo
+		@Bg += @@Alpha * @dBg
+		#puts "<< " + @Wg[0,0].to_s
+		### Change related to cell input
+		@dWi = DFloat.zeros(1, @sz)
+		@dWf = DFloat.zeros(1, @sz)
+		@dWo = DFloat.zeros(1, @sz)
+		@dWg = DFloat.zeros(1, @sz)
+		### Change related to cell state
+		@dUi = DFloat.zeros(1, @sz)
+		@dUf = DFloat.zeros(1, @sz)
+		@dUo = DFloat.zeros(1, @sz)
+		@dUg = DFloat.zeros(1, @sz)
+		### Change required to Bias 
+		@dBi = DFloat.zeros(1, @sz)
+		@dBf = DFloat.zeros(1, @sz)
+		@dBo = DFloat.zeros(1, @sz)
+		@dBg = DFloat.zeros(1, @sz)
+	end
+    # Transfer functions 
+	def tanhDer(v)
+		#input vector must be a horisontal vector
+		output_vector = DFloat.zeros(v.shape[0], v.shape[1])
+		for i in 0...v.shape[0]
+			for j in 0...v.shape[1]
+				output_vector[i,j] = 1 - (v[i,j]**2)
+			end
+		end
+		return output_vector
+	end
+	def sigmoidDer(v)
+		#input vector must be a horisontal vector
+		output_vector = DFloat.zeros(v.shape[0], v.shape[1])
+		for i in 0...v.shape[0]
+			for j in 0...v.shape[1]
+				output_vector[i,j] = v[i,j] * (1 - v[i,j])
+			end
+		end
+		return output_vector
+	end
+	def sigmoidVector(v)
+		#input vector must be a horisontal vector
+		output_vector = DFloat.zeros(v.shape[0], v.shape[1])
+		for i in 0...v.shape[0]
+			for j in 0...v.shape[1]
+				output_vector[i,j] = sigmoid(v[i,j])
+			end
+		end
+		return output_vector
+	end
+	def sigmoid(value_)
+		output_value =  1 / (1 + Math.exp(-1 * value_))
+		return output_value
+	end
+	# Getters and Setters
+	def setXt(xt)
+		if xt.shape()[0] != 1
+			puts "Size of xt: " + xt.shape().to_s
+			raise "Setting @Xt of LSTM cell raised an incorrect dimension error"
+			return
+		end
+		@Xt = xt
+	end
+	def setYt(yt)
+		if yt.shape()[0] != 1
+			puts "Size of yt: " + yt.shape().to_s
+			raise "Setting @Yt of LSTM cell raised an incorrect dimension error"
+			return
+		end
+		@Yt = yt
+	end
+	def setHprev(hp)
+		if hp.shape()[0] != 1
+			puts "Size of hp: " + hp.shape().to_s
+			raise "Setting @Hprev of LSTM cell raised an incorrect dimension error"
+			return
+		end
+		@Hprev = hp
+	end
+	def setCprev(cp)
+		@Cprev = cp
+		if cp.shape()[0] != 1
+			puts "Size of cp: " + cp.shape().to_s
+			raise "Setting @Cprev of LSTM cell raised an incorrect dimension error"
+			return
+		end
+	end
+	def getBottomDeltaHt()
+		return @bottom_diff_h
+	end
+	def getBottomDeltaCt()
+		return @bottom_diff_c
+	end
+	def getYt()
+		return @Yt
+	end
+	def getHt()
+		return @Ht
+	end
+	def getCt
+		return @Ct
+	end
+end

data/lib/DICTIONARY.rb

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+=begin
+Created: 	14/09/2023.
+Version: 	1.0.0
+=end
+require 'numo/narray'
+include Numo
+=begin 
+Dictionary
+=end
+class DICTIONARY < ENCODER
+	def init(string, x_dim)
+		@x_dim = x_dim
+		@frequencyHash = wordFrequency(string)
+		@stringToEncoding, @encodingToString = hotEncodeVocabulary(@frequencyHash, x_dim)
+	end
+	def getFrequencyHash()
+		return @frequencyHash
+	end
+	def getEncodingHashs()
+		return @stringToEncoding, @encodingToString
+	end
+	def wordFrequency(words)
+		if words.is_a?(String)
+			words = words.split
+		end
+		frequency = {}
+		entries = 0
+		for i in 0...words.length()
+			if frequency[words[i]] == nil
+				frequency[words[i]] = 1
+				entries += 1
+			else
+				frequency[words[i]] = frequency[words[i]] + 1
+			end
+		end
+		return frequency.sort_by {|k, v| v}.reverse
+	end
+	def hotEncodeVocabulary(hash, maxEntries)
+		stringToEncoding = {}
+		encodingToString = {}
+		binary = 0b1
+		hash.each do |key, value|
+			stringToEncoding["#{key}"] = binary
+			encodingToString[binary] = "#{key}"
+			binary = binary << 1
+			if (binary) == (0b1 << maxEntries)
+				break;
+			end
+		end
+		return stringToEncoding, encodingToString
+	end
+	def readFileDataArray(fileDataArray, fileIndex, start, input_len, predict_len)
+		fileWordArray = (fileDataArray[fileIndex]).split
+		return fileWordArray[start, input_len], fileWordArray[(start+predict_len), (input_len)]
+	end
+	def encodeArray(wordArray, hash=@stringToEncoding)
+		if wordArray.instance_of? String
+			wordArray = wordArray.split()
+		end 
+		array = Int32.zeros(wordArray.length(), @x_dim)
+		for i in 0...wordArray.length()
+			word = wordArray[i]
+			encoding = hash[word]
+			if encoding != nil
+				binaryArray = binaryToArray(encoding, @x_dim)
+				array[i, true] = binaryArray
+			end
+		end
+		return array
+	end
+	def binaryToArray(binary, x_dim)
+		binaryFormatted = ((0b1 << (x_dim+1) ^ binary*2)).to_s(2)[1, x_dim]
+		binaryArray = DFloat.zeros(1, x_dim)
+		binaryArray = binaryFormatted.split("").map(&:to_i)
+		return binaryArray
+	end
+	def arrayToBinary(array)
+		binaryString = array.to_a.join("")
+		binary = binaryString.to_i(2)
+		return binary
+	end
+	def decodeArray(encodedArray, hash=@encodingToString)
+		output = ""
+		for i in 0...encodedArray.shape()[0]
+			decodedWord = hash[arrayToBinary(encodedArray[i, true])]
+			if decodedWord != nil
+				output += decodedWord + " "
+			else 
+				output += "@ "
+			end
+		end
+		return output
+	end
+	def decodeArrayByMaximum(encodedArray, hash=@encodingToString)
+		output = ""
+		for i in 0..encodedArray.shape()[0]-1
+			if encodedArray[i, true].to_a.max != 0
+				max_element = encodedArray[i, true].to_a.each_with_index.max[1]
+				encodedArrayBW = Int32.zeros(encodedArray[i, true].shape())
+				encodedArrayBW[max_element] = 1
+				decodedWord = hash[arrayToBinary(encodedArrayBW)]
+				if decodedWord != nil
+					output += decodedWord + " "
+				else 
+					output += "@ "
+				end
+			else 
+				output += "$ "
+			end
+		end
+		return output
+	end
+	def viewHash(hash)
+		puts "key -> value"
+		entries = 0
+		hash.each do |key, value|
+			puts key.to_s + " -> " + value.to_s
+			entries += 1
+		end
+		puts "Entires in hash: " + entries.to_s
+	end
+end

data/lib/ENCODER.rb

@@ -0,0 +1,132 @@
+#!/usr/bin/env ruby
+=begin
+██╗░░░░░░██████╗████████╗███╗░░░███╗
+██║░░░░░██╔════╝╚══██╔══╝████╗░████║
+██║░░░░░╚█████╗░░░░██║░░░██╔████╔██║
+██║░░░░░░╚═══██╗░░░██║░░░██║╚██╔╝██║
+███████╗██████╔╝░░░██║░░░██║░╚═╝░██║
+╚══════╝╚═════╝░░░░╚═╝░░░╚═╝░░░░░╚═╝
+Created: 	14/09/2023.
+Version: 	1.0.0
+Author: 	Ryan May
+This is a text generator LSTM developed in Ruby. 
+In this project I gain more of an understanding of the training and creation of LSTM networks.
+This LSTM network utilises the Numo::Narray library to calculate cell states and the cell network.
+Expansion on this project will be utilised in my Honours project. 
+=end
+require 'matrix' 		# https://www.rubyguides.com/2019/01/ruby-matrix/
+require 'numo/narray'
+include Numo
+=begin 
+███████╗███╗░░██╗░█████╗░░█████╗░██████╗░███████╗██████╗░
+██╔════╝████╗░██║██╔══██╗██╔══██╗██╔══██╗██╔════╝██╔══██╗
+█████╗░░██╔██╗██║██║░░╚═╝██║░░██║██║░░██║█████╗░░██████╔╝
+██╔══╝░░██║╚████║██║░░██╗██║░░██║██║░░██║██╔══╝░░██╔══██╗
+███████╗██║░╚███║╚█████╔╝╚█████╔╝██████╔╝███████╗██║░░██║
+╚══════╝╚═╝░░╚══╝░╚════╝░░╚════╝░╚═════╝░╚══════╝╚═╝░░╚═╝
+The encoder class is used to translate input characters and sentances into one-hot encoded vectors. 
+Additionally, the encoder class contains functions to handle file reading, regex filtering, and conversions
+between 'Matrix' and 'NArray' types.
+=end
+class ENCODER
+	def init(charmatrix = nil)
+		if charmatrix == nil
+			@Length = 56
+			@SelectionMatrix = Matrix.build(1,56) {0} # 1 row 32 columns
+			@CharMatrix = Array['.',',',"\s",'!',
+								'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',
+								'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
+		else 
+			@Length = charmatrix.length()
+			@SelectionMatrix = Matrix.build(1, charmatrix.length()) { 0 }
+			@CharMatrix = charmatrix
+		end
+	end
+	def matrixToNArray(matrix)
+		nArray = DFloat[*matrix.to_a]
+		return nArray
+	end
+	def nArrayToMatrix(nArray)
+		#puts nArray.to_a.map(&:inspect)
+		matrix = Matrix[*nArray.to_a]
+		#puts matrix.to_a.map(&:inspect)
+		return matrix
+	end
+	def listFilesInDirectory(path)
+		fileNameArray = Dir.entries(path).reject {|f| File.directory?(f) || f[0].include?('.')}
+		return fileNameArray
+	end
+	def readPlaintextFilesInDirectory(path)
+		fileDataArray = Array.new(0) { "" }
+		# Get names of all files in a folder. 
+		fileNameArray = Dir.entries(path).reject {|f| File.directory?(f) || f[0].include?('.')}
+		# itterate through all files in Array
+		for index in 0...fileNameArray.length()
+			puts "reading file " + path + "/" + fileNameArray[index]
+			fileData = readPlaintextfile(path + "/" + fileNameArray[index])
+			fileDataArray = fileDataArray << fileData
+		end
+		return fileDataArray
+	end
+	def readFileDataArray(fileDataArray, index, start, input_len, predict_len)
+		combination = hotEncodeSentance(filter(fileDataArray[index])[start,predict_len+input_len])
+		return combination
+	end
+	def readPlaintextfile(fileName)
+		file = File.open(fileName)
+		file_data = file.read
+		file.close
+		return file_data
+	end
+	def filter(sentance, regex=nil)
+		if regex == nil
+			sentance = sentance.gsub(/[^A-Za-z\., ]/, '')
+		else 
+			sentance = sentance.gsub(regex, '')
+		end
+		return sentance
+	end
+	def hotEncodeSentance(sentance)
+		letters = sentance.split(//)
+		matrix = Matrix.build(0, 0){0}
+		for index in 0...letters.length()
+			charvector = hotEncodeCharacter(letters[index])
+			if charvector != nil
+				matrix = Matrix.rows(matrix.to_a << charvector.to_a)
+			end
+		end
+		return matrix
+	end
+	def hotDecodeSentance(matrix)
+		sentance = ""
+		for index in 0...matrix.row_count()
+			charvector = matrix.row(index)
+			char = hotDecodeCharacter(charvector)
+			sentance = sentance + char 
+		end
+		return sentance
+	end
+	def hotEncodeCharacter(char)
+		# reset selection matrix
+		@SelectionMatrix = Matrix.build(1,@Length) {0}
+		index = @CharMatrix.index char
+		@SelectionMatrix[0,index] = 1
+		return @SelectionMatrix.row(0)
+	end
+	def hotDecodeCharacter(vector)
+		# convert vector to array so we can search for the up bit
+		vectorArray = vector.to_a
+		index = vectorArray.each_with_index.max[1] 
+		if index != nil
+			return @CharMatrix[index]
+		else 
+			return '@'
+		end
+	end
+	def stringDifferencePercent(a, b)
+	  longer = [a.size, b.size].max
+	  same = a.each_char.zip(b.each_char).count { |a,b| a == b }
+	  similarity = (longer - same) / a.size.to_f
+	  return similarity
+	end
+end

data/lib/NETWORK.rb

@@ -0,0 +1,163 @@
+#!/usr/bin/env ruby
+=begin
+██╗░░░░░░██████╗████████╗███╗░░░███╗
+██║░░░░░██╔════╝╚══██╔══╝████╗░████║
+██║░░░░░╚█████╗░░░░██║░░░██╔████╔██║
+██║░░░░░░╚═══██╗░░░██║░░░██║╚██╔╝██║
+███████╗██████╔╝░░░██║░░░██║░╚═╝░██║
+╚══════╝╚═════╝░░░░╚═╝░░░╚═╝░░░░░╚═╝
+Created: 	14/09/2023.
+Version: 	1.0.0
+Author: 	Ryan May
+This is a text generator LSTM developed in Ruby. 
+In this project I gain more of an understanding of the training and creation of LSTM networks.
+This LSTM network utilises the Numo::Narray library to calculate cell states and the cell network.
+Expansion on this project will be utilised in my Honours project. 
+=end
+require_relative 'ENCODER'
+require_relative 'CELL'
+require_relative 'DICTIONARY'
+require 'matrix' 		# https://www.rubyguides.com/2019/01/ruby-matrix/
+require 'numo/narray'
+include Numo
+=begin
+██╗░░░░░░██████╗████████╗███╗░░░███╗ ███╗░░██╗███████╗████████╗░██╗░░░░░░░██╗░█████╗░██████╗░██╗░░██╗
+██║░░░░░██╔════╝╚══██╔══╝████╗░████║ ████╗░██║██╔════╝╚══██╔══╝░██║░░██╗░░██║██╔══██╗██╔══██╗██║░██╔╝
+██║░░░░░╚█████╗░░░░██║░░░██╔████╔██║ ██╔██╗██║█████╗░░░░░██║░░░░╚██╗████╗██╔╝██║░░██║██████╔╝█████═╝░
+██║░░░░░░╚═══██╗░░░██║░░░██║╚██╔╝██║ ██║╚████║██╔══╝░░░░░██║░░░░░████╔═████║░██║░░██║██╔══██╗██╔═██╗░
+███████╗██████╔╝░░░██║░░░██║░╚═╝░██║ ██║░╚███║███████╗░░░██║░░░░░╚██╔╝░╚██╔╝░╚█████╔╝██║░░██║██║░╚██╗
+╚══════╝╚═════╝░░░░╚═╝░░░╚═╝░░░░░╚═╝ ╚═╝░░╚══╝╚══════╝░░░╚═╝░░░░░░╚═╝░░░╚═╝░░░╚════╝░╚═╝░░╚═╝╚═╝░░╚═╝
+This class handles the single-height LSTM network. The LSTM network comprises of an array of LSTM cell objects, 
+an input matrix, and a target matrix. 
+Forward propagation for the network, and backward network propagation is implemented here. 
+This is seperate from the cellular-level forward and back propagation in the LSTM_CELL class. 
+=end
+class LSTM_NETWORK
+	def init(nodes, x_dim, alpha, terminal_output=nil)
+		@dict = DICTIONARY. new
+		@encoder = ENCODER. new
+		@encoder.init()
+		@sz = x_dim
+		@@Alpha = alpha
+		@Nodes = nodes
+		### Creating LSTM network (matrix of nodes)
+		@lstm_nodes = Matrix.build(1, @Nodes) { LSTM_CELL }
+		for i in 0...@lstm_nodes.column_count()
+			@lstm_nodes[0,i] = LSTM_CELL. new
+			@lstm_nodes[0,i].init(@@Alpha, @sz, terminal_output)
+		end
+		## Input and target
+		@Input = DFloat.zeros(nodes, @sz)
+		@Target = DFloat.zeros(nodes, @sz)
+	end
+	def getLSTMNodes()
+		return @lstm_nodes
+	end
+	def setDictionary(dictionary)
+		@dict = dictionary
+	end
+	def setTarget(target, mode=nil)
+		if mode == "encoded"
+			@Target = target
+		elsif target.instance_of? String
+			@Target = @encoder.matrixToNArray(@encoder.hotEncodeSentance(target))
+		elsif target.instance_of? Array
+			@Target = @dict.encodeArray(target)
+		else
+			raise "Target input is not of type Array or String"
+		end
+	end
+	def setInput(input, mode=nil)
+		if mode == "encoded"
+			@Input = input
+		elsif input.instance_of? String
+			@Input = @encoder.matrixToNArray(@encoder.hotEncodeSentance(input))
+		elsif input.instance_of? Array
+			@Input = @dict.encodeArray(input)
+		else
+			raise "Target input is not of type Array or String"
+		end
+	end
+	def getTarget(mode="word_mode")
+		if mode == "word_mode"
+			return @dict.decodeArray(@Target)
+		elsif mode == "char_mode"
+			return @encoder.hotDecodeSentance(@encoder.nArrayToMatrix(@Target))
+		elsif mode == "array_mode"
+			return @Target
+		end
+	end
+	def getInput(mode="word_mode")
+		if mode == "word_mode"
+			return @dict.decodeArray(@Input)
+		elsif mode == "char_mode"
+			return @encoder.hotDecodeSentance(@encoder.nArrayToMatrix(@Input))
+		elsif mode == "array_mode"
+			return @Input
+		end
+	end
+	def getOutput(mode="word_mode")
+		if mode == "word_mode"
+			return @dict.decodeArrayByMaximum(@Output)
+		elsif mode == "char_mode"
+			return @encoder.hotDecodeSentance(@encoder.nArrayToMatrix(@Output))
+		elsif mode == "array_mode"
+			return @Output
+		end
+	end
+	def forwardPropagate(initialH=DFloat.zeros(1, @sz), initialC=DFloat.zeros(1, @sz))
+		@Output = DFloat.zeros(@Nodes, @sz)
+		# Start from front of network and work forwards
+		if initialH != nil && initialC != nil
+			@lstm_nodes[0,0].setHprev(initialH)
+			@lstm_nodes[0,0].setCprev(initialC)
+		else 
+			@lstm_nodes[0,0].setHprev(DFloat.zeros(1, @sz))
+			@lstm_nodes[0,0].setCprev(DFloat.zeros(1, @sz))
+		end
+		
+		node_input 	= DFloat[*[@Input[0, true].to_a]]
+		node_target = DFloat[*[@Target[0, true].to_a]]
+
+		@lstm_nodes[0,0].setXt(node_input)
+		@lstm_nodes[0,0].setYt(node_target)
+		@lstm_nodes[0,0].forwardPropagation()
+
+		@Output[0, true] = @lstm_nodes[0,0].getHt()
+		# Nodes 1 to end
+		for i in 1...@lstm_nodes.column_count()
+			# Indexing is working now
+			node_input 	= DFloat[*[@Input[i, true].to_a]]
+			node_target = DFloat[*[@Target[i, true].to_a]]
+			@lstm_nodes[0,i].setHprev(@lstm_nodes[0,i-1].getHt())
+			@lstm_nodes[0,i].setCprev(@lstm_nodes[0,i-1].getCt())
+			@lstm_nodes[0,i].setXt(node_input)
+			@lstm_nodes[0,i].setYt(node_target)
+			@lstm_nodes[0,i].forwardPropagation()
+			@Output[i, true] = @lstm_nodes[0,i].getHt()
+		end
+	end
+	def backwardPropagate()
+		i = 0
+		delta_h_init = DFloat.zeros(@lstm_nodes[0, i].getHt().shape())
+        delta_h_init = 2 * (@lstm_nodes[0, i].getYt() - @lstm_nodes[0, i].getHt())
+		delta_c_init = DFloat.zeros(1, @sz)
+		@lstm_nodes[0,i].backwardPropagation(delta_h_init, delta_c_init)
+
+		i += 1
+		while i <= @lstm_nodes.column_count()-1 do
+			#puts "BP cell: " + i.to_s
+			delta_h = DFloat.zeros(@lstm_nodes[0, i].getHt().shape())
+        	delta_h = 2 * (@lstm_nodes[0, i].getYt() - @lstm_nodes[0, i].getHt())
+			delta_h += @lstm_nodes[0, i-1].getBottomDeltaHt()
+			delta_c = @lstm_nodes[0, i-1].getBottomDeltaCt()
+			@lstm_nodes[0,i].backwardPropagation(delta_h, delta_c)
+			i += 1
+		end
+	end
+	def applyWeightChange()
+		for i in 0...@lstm_nodes.column_count()
+			@lstm_nodes[0,i].applyWeightChange()
+		end
+	end
+end

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: basic-lstm
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Ryan May
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-06-30 00:00:00.000000000 Z
+dependencies: []
+description:
+email: 19477774@student.curtin.edu.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/CELL.rb
+- lib/DICTIONARY.rb
+- lib/ENCODER.rb
+- lib/NETWORK.rb
+homepage: https://github.com/ryan-n-may/Ruby_LSTM
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.15
+signing_key:
+specification_version: 4
+summary: A basic LSTM package
+test_files: []