Understanding Depth

Surface-level knowledge is not enough anymore. You need to have academic knowledge, diverse skills, and the ability to separate noise from the real trends because engagement is the currency of social media, not the accuracy, so there will be a lot of noise there. By diverse skills, he doesn’t mean knowing both about NLP and CV; he means knowing about training ML models while also knowing about how to deploy them, scale them, and build an application on them to be valuable even if the AI hype completely deflates tomorrow. He also gave a practical strategy to filtering noise: Develop trusted sources and filter them actively. Learn more about the fundamentals of the hyped tech (enters the academic knowledge) before judging its impact (e.g., Hollywood is over, SWE is over). And always aware of the trends and know why it is a trend right now. As an example, think about “AI Agents” before directly going into implementation, understand how they work, “when” and “why” it adds value, and when it won’t add any value. And how will it help?

Business Focus

You need to translate the capabilities of AI into a real business outcome. If you go directly with the hype, aka agents, these days, you will fail. First, you need to peel apart the business requirements, ask “why” and “what” a lot of times to understand the real bottleneck/problem. Additionally, risks of mispredictions, hallucinations, biases, and misuses (some edge cases you will never think of will be found by the users) are here and will stay here. Knowing how to manage those risks while making a process an AI-enabled process is critical.

Bias Towards Delivery

Building cool things that have no value is not that important anymore (as it was when hype started). You need to build useful things; if it is both useful and cool, it is definitely better. Show that you can ship working solutions more than demos. An example from him: Before applying to Google Cloud, while he was writing a Java book, he made a Java application that runs on the Google Cloud and showed it on the interview, which turned the interview process into questions about his app instead of weird questions like how many windows in New-York.

And some additional points:

• You will make mistakes, so learn from them and also be helpful when someone else makes a mistake
• Vibe coding is good unless you mindlessly copy-paste the code. Every time you use AI to generate code, you are taking technical debt.
• Learning how to fine-tune those small LLMs is currently one of the most important things, due to privacy reasons in a lot of industries

If you want to watch:

Introduction to Message Passing in GNNs

For those unfamiliar, Graph Neural Networks (GNNs) are a class of neural networks designed to operate on graph-structured data. They leverage the relationships between nodes (entities) and edges (connections) to learn representations that capture both local and global graph structures. Message passing is a fundamental operation in GNNs, where information is exchanged between nodes and their neighbors to update node representations.

In PyG, message passing is typically implemented using the MessagePassing class, which provides a flexible framework for defining custom message-passing schemes. It has 4 important methods:

1. Propagate

This function is responsible for orchestrating the message-passing process. It takes an edge index, a.k.a adjacency matrix, as a mandatory parameter. You can (and probably must) give feature matrix x. In addition, you can pass any other necessary data for the later steps we will see. You don’t update/override this function; you pass the necessary data to it to be further used in the next steps.

Some example parameters:

propagate(edge_index, x=x)
propagate(edge_index, x=x, edge_attr=edge_attr)
propagate(edge_index, x=x, norm=norm)

2. Message

This is where you create a message for the source node from neighboring nodes. This function takes x_j as input by default, which is the feature vector of the source nodes. This means you have to give your feature matrix named as x=x in the propagate function, or override the parameter name in the message function.

You can also access any other data you passed in the propagate function, such as edge attributes or normalization factors. For example, in the second example of the propagate function, you give norm parameter, you can access it in the message function as norm.

Some example parameters:

message(x_j)
message(x_j, norm)
message(x_j, x_i, norm, edge_index, x)

Also, an example implementation that normalizes the messages by their node’s degree:

def message(self, x_j, norm):
    # x_j has shape [E, out_channels]
    print("Creating messages...")
    print(f"x_j shape: {x_j.shape}")
    print(f"norm shape: {norm.shape}")

    # Step 4: Normalize node features.
    return norm.view(-1, 1) * x_j

3. Aggregate

Now that you have messages from your neighboring nodes, this is where you aggregate those messages. This method calls the Aggregator object of the class by default, which is set to “add” by default. You can change it to “mean” or “max” when you initialize your custom MessagePassing class or implement your own aggregate function.

You can also override this method to implement your own aggregation logic. By overriding this method, you can weight the messages using any data you want, before using the default sum aggregation as an example.

It takes the following parameters:

• inputs which is the messages created in the message function
• index that says the target node each message belongs to

And whatever you want from the propagate function.

4. Update

This is the final step where you update the target node features using the aggregated messages. Depending on your architecture, you might do nothing here and return the aggregated messages, such as when you add self-loops. Alternatively, add the source node features to the aggregated messages or pass them through a neural network layer.

It takes inputs, which is the aggregated messages from the aggregate function and whatever you want from the propagate function.

Conclusion

In this blog post, we explored how message passing works in PyTorch Geometric by breaking down the key methods of the MessagePassing class: propagate, message, aggregate, and update. If you want to customize your GNN architecture and experiment with different message-passing schemes, understanding these methods is critical. With this knowledge, you can implement your own GNN layers and tailor them to your specific needs. I will drop a simple working code that I’ve borrowed from the PyG documentation below for reference.

from typing import Optional

import torch
from torch import Tensor
from torch.nn import Linear, Parameter
from torch_geometric.nn import MessagePassing
from torch_geometric.utils import add_self_loops, degree
from torch_geometric.data import Data

class GCNConv(MessagePassing):
    def __init__(self, in_channels, out_channels):
        super().__init__(aggr='add')  # "Add" aggregation (Step 5).
        self.lin = Linear(in_channels, out_channels, bias=False)
        self.bias = Parameter(torch.empty(out_channels))

        self.reset_parameters()

    def reset_parameters(self):
        self.lin.reset_parameters()
        self.bias.data.zero_()

    def forward(self, x, edge_index):
        # x has shape [N, in_channels]
        # edge_index has shape [2, E]
        print("Forward pass...")
        print(f"x shape: {x.shape}")
        print(f"edge_index shape: {edge_index.shape}")

        # Step 1: Add self-loops to the adjacency matrix.
        edge_index, _ = add_self_loops(edge_index, num_nodes=x.size(0))

        # Step 2: Linearly transform node feature matrix.
        x = self.lin(x)

        # Step 3: Compute normalization.
        source, target = edge_index
        deg = degree(target, x.size(0), dtype=x.dtype)
        deg_inv_sqrt = deg.pow(-0.5)
        deg_inv_sqrt[deg_inv_sqrt == float('inf')] = 0
        norm = deg_inv_sqrt[source] * deg_inv_sqrt[target]

        # Step 4-5: Start propagating messages.
        out = self.propagate(edge_index, x=x, norm=norm)

        # Step 6: Apply a final bias vector.
        out = out + self.bias

        return out

    def message(self, x_i, x_j, norm, edge_index):
        # x_j has shape [E, out_channels]
        print("Creating messages...")
        print(f"x_i shape: {x_i.shape}")
        print(f"x_j shape: {x_j.shape}")
        print(f"norm shape: {norm.shape}")

        # Step 4: Normalize node features.
        return norm.view(-1, 1) * x_j

    def aggregate(
        self,
        inputs: Tensor,
        index: Tensor,
        ptr: Optional[Tensor] = None,
        dim_size: Optional[int] = None,
    ) -> Tensor:
        print("Aggregating messages...")
        print(f"Inputs shape: {inputs.shape}")
        print(f"Index shape: {index.shape}")
        print(index)
        return super().aggregate(inputs, index, ptr, dim_size)

    def update(self, inputs: Tensor) -> Tensor:
        print("Updating node embeddings...")
        print(f"Inputs shape: {inputs.shape}")
        print(inputs)
        return super().update(inputs)


edge_index = torch.tensor([[0, 1],
                           [1, 0],
                           [1, 2],
                           [2, 1]], dtype=torch.long)
x = torch.tensor([[-1], [0], [1]], dtype=torch.float)

data = Data(x=x, edge_index=edge_index.t().contiguous())

conv = GCNConv(1, 2)
out = conv(data.x, data.edge_index)
print(out)

References

• PyTorch Geometric Documentation
• For GNN basics, and also for the headline image reference
• Also, a great YouTube video for GNN basics from Stanford

Thanks for coming so far, have fun!

Topic and Stress

You can divide a sentence into two parts: the topic and the stress. The topic is what the sentence is about, and the stress is what you want to say about the topic or what is new information.

Example:

Accounts of depression evolved after psychologists introduced the concepts of defeat and entrapment.

Run-Ons

A run-on is two complete thoughts run together with no sign to mark the break between them or with just a comma:

Then, in [2], they also presented a bisection algorithm to compute -pseudospectral abscissa of a fixed matrix, i.e. , and tried to compute minimum -pseudospectral abscissa over feasible matrices, however, an algorithm wasn’t presented yet.

vs

Then, in [2], they also presented a bisection algorithm to compute -pseudospectral abscissa of a fixed matrix, i.e. . They also tried to compute minimum -pseudospectral abscissa over feasible matrices. However, an algorithm wasn’t presented yet.

Fragments

A sentence fragment is a group of words that lacks a subject or a verb and does not express a complete thought:

Purdue offers many majors in engineering. Such as electrical, chemical, and industrial engineering.

Purdue offers many majors in engineering such as electrical, chemical, and industrial engineering.

Parallelism

Words in a pair or series should have a parallel structure.

Not Parallel: The production manager was asked to write his report quickly, accurately, and in a detailed manner.

Parallel: The production manager was asked to write his report quickly, accurately, and thoroughly.

Misplaced Modifiers

Misplaced modifiers do not describe the word in the way the writer intended because of their wrong place in a sentence.

George couldn’t drive to work in his small sports car with a broken leg.

With a broken leg, George couldn’t drive to work in his small sports car.

In this example, we and transformer models know that George has a broken leg, not the car. But grammatically, the modifier “with a broken leg” seems to describe the car. This is an easy example but in a academic text, it can be more complex and harder to spot.

In order to avoid misplaced modifiers, place the words as close as possible to what they describe.

Dangling Modifiers

A modifier that opens a sentence must be followed immediately by the word it is meant to describe. Otherwise the sentence takes on an unintended meaning.

While smoking a pipe, my dog sat with me.

While smoking a pipe, I sat with my dog.

While I was smoking a pipe, my dog sat with me.

Again, this is also an easy example but in a academic text, it can be more complex and harder to spot.

Sentence Variety

• Too many sentences with the same structure and length can grow monotonous for readers.

• Varying sentence style and structure can also reduce repetition and add emphasis.

• Long sentences work well for incorporating a lot of information, and short sentences can often maximize crucial points.

Change the Rhythm!

Change the rhythm of your writing by varying sentence length and structure. As you will see the example below, varying sentence length and structure can make your writing more interesting and engaging.

Vary the rhythm by alternating short and long sentences:

The Winslow family visited Canada and Alaska last summer to find some Native American art. In Anchorage stores they found some excellent examples of soapstone carvings. But they couldn’t find a dealer selling any of the woven wall hangings they wanted. They were very disappointed when they left Anchorage empty-handed.

The Winslow family visited Canada and Alaska last summer to find some native American art, such as soapstone carvings and wall hangings. Anchorage stores had many soapstone items available. Still, they were disappointed to learn that wall hangings, which they had especially wanted, were difficult to find. Sadly, they left empty-handed.

I think I see something similar to this in the novels I’ve read.

Repeated Subjects or Topics

• Handling the same topic for several sentences can lead to repetitive sentences. When that happens, consider using these parts of speech to fix the problem:

Relative pronouns

Indiana used to be mainly an agricultural state. It has recently attracted more industry. Indiana, which used to be mainly an agricultural state, has recently attracted more industry.

Participles

Wei Xie was surprised to get a phone call from his sister. He was happy to hear her voice again. Surprised to get a phone call from his sister, Wei Xie was happy to hear her voice again.

Prepositions

The university has been facing pressure to cut its budget. It has eliminated funding for important programs. Under pressure to cut its budget, the university has eliminated funding for important programs.

Final Words

Finally, all these rules and tips are not strict rules, but guidelines to help you improve your writing. Also, it is very easy to forget them. The best thing you can do is keep writing constantly, while editing your own writing with these rules in mind. Over time, you will internalize these rules and your writing will improve. I also believe that reading a lot of well-written articles and books will help you improve your writing skills.

References

• Koc University Writing Center
• Sentence Variety. (2018). Retrieved from https://owl.purdue.edu/owl/general_writing/academic_writing/sentence_variety/index.html
• Making Complex Writing Intelligible with Known-New Contract. (2018). Global Communication Center, Carnegie Mellon University. Retrieved from https://www.cmu.edu/gcc/handouts/old-new-handout-pdf

References

• BU-TD Model: “Image interpretation by iterative bottom-up top-down processing”
• T5 Model: “Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer”

Pre-training

Pre-training is done with two different tasks:

1. Masked Language Model (MLM)
2. Next Sentence Prediction (NSP)

import tensorflow as tf

dataset = tf.data.experimental.make_csv_dataset(
    'data/kaggle_toxic_comments/train.csv', batch_size=batch_size, num_epochs=1
    , select_columns=['comment_text', 'toxic', 'severe_toxic', 'obscene', 'threat', 'insult', 'identity_hate'])

dataset = dataset.unbatch()
validation = dataset.take(10000)
train = dataset.skip(10000)

train = train.map(lambda data: (
    dataset_preprocessing(data['comment_text']),
    [data['toxic'],
     data['severe_toxic'],
     data['obscene'],
     data['threat'],
     # data['sexual_explicit'],
     data['insult'],
     data['identity_hate'],
     ])).batch(batch_size).cache().prefetch(tf.data.AUTOTUNE)

validation = validation.map(lambda data: (
    dataset_preprocessing(data['comment_text']),
    [data['toxic'],
     data['severe_toxic'],
     data['obscene'],
     data['threat'],
     # data['sexual_explicit'],
     data['insult'],
     data['identity_hate'],
     ])).batch(batch_size).cache().prefetch(tf.data.AUTOTUNE)

return train, test

from tensorflow.keras.layers import *
import tensorflow_hub as hub

text_input = tf.keras.layers.Input(shape=(), dtype=tf.string)
preprocessor = hub.KerasLayer(
    "https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3")
encoder_inputs = preprocessor(text_input)
encoder = hub.KerasLayer(
    "https://tfhub.dev/tensorflow/bert_en_uncased_L-24_H-1024_A-16/4",
    trainable=False)
outputs = encoder(encoder_inputs)
pooled_output = outputs["pooled_output"]  # [batch_size, 512].
sequence_output = outputs["sequence_output"][:, 0, :]

classification_output = Dense(6, activation='sigmoid')(sequence_output)

embedding_model = tf.keras.Model(text_input, classification_output)

embedding_model.compile(
    optimizer=tf.keras.optimizers.Nadam(learning_rate=0.025),
    loss=tf.keras.losses.BinaryCrossentropy(),
    metrics=[tf.keras.metrics.AUC()],
    run_eagerly=False

)

embedding_model.summary()

embedding_model.fit(x=train_data, validation_data=test_data, epochs=2)

References

1. https://arxiv.org/pdf/1810.04805.pdf - The BERT paper.
2. http://jalammar.github.io/illustrated-bert/ - Awesome and more detailed explanation of BERT model
3. https://tfhub.dev/tensorflow/bert_en_uncased_L-24_H-1024_A-16/4 - An example BERT model from Tensorflow Hub

Encoder and Decoder Stacks

[[0, 1, 1, 1],
 [0, 0, 1, 1],
 [0, 0, 0, 1],
 [0, 0, 0, 0]]

scaled_attention_logits -= mask * 1e9

Use this crossentropy loss function when there are two or more label classes.
We expect labels to be provided as integers.There should be ‘# classes’ floating point values per feature for ‘y_pred’ and a single floating point value per feature for ‘y_true’.
Example:

y_true = [1, 2]
y_pred = [[0.05, 0.95, 0], [0.1, 0.8, 0.1]]

Self-Attention

Let’s suppose we want to translate the following sentence:

“The books were on the shelves because they are old.”

What does “they” in this sentence refer to? Is it referring to the books or the shelves? It’s a simple question to a human, but not as simple as an algorithm. Self-attention allows the model to associate “they” with books.

An attention mechanism maps a query and a key-value pair to an output. All of them are vectors. The way to calculate output is the weighted sum of the values. Weights are computed by a function that uses query and key as input. These weights are not trainable, query and key values are calculated by trainable and learned weights.

Query, Key, and Value are created from the encoder’s input vectors(e.g. embedding of input words for the first layer) by multiplying these input vectors with 3 different weight matrices , , that can be trained during the training process. Every layer (both encoder and decoder layers) in the Transformer model has its , , matrices.

Multi-Head Attention

The idea/question behind multi-head self-attention is: “How do we improve the model’s ability to focus on different features of the input sentence?”.

1. With 1 head self-attention, the encoding could be dominated by the actual word.
2. Multi-head attention allows the model to learn different semantic meanings of attention. Eg. One for grammar, one for vocabulary, etc.

For example, if we have head=8 (referenced as h), there will be 8 different Q, K, and V matrices and 8 different outputs. , weights will have dimension:

• :
• :
• :

and the outputs will be concatenated and multiplied by another weight matrix with dimension to get the final

Positional Encoding

As the Transformer model doesn’t use recurrence, there isn’t any position information(time step t) in the model input. It is just a bag of words. To provide the model this important information, we inject(add) some information vector( positional encoding) to each embedding. These positional encoding vectors have the same dimension as embeddings.

One way to add this information is having a second embedding, as we have an embedding vector for “computer”, why shouldn’t we have an embedding for position 3? With this approach, the model can learn positional embeddings during training. The problem with this approach is, say we have 1000 training examples and the maximum input length is 50. If 800 of these training examples have the length of 30, the other 20 embedding vectors will be poorly trained and may not generalize well in practice.

As an alternative, we can use a static function that takes an integer input and give a vector in a way that captures the relationship between positions. This function should give that position 8 is more related to position 9 than position

30. In the Transformer model, authors decided to use sine and cosine functions of different frequencies:

Here, pos is the position of the token, and i is the dimension. Each dimension of these positional encodings corresponds to a sinusoid. (A curve similar to the sine function but possibly shifted in phase, period, amplitude, or any combination thereof.) The wavelengths form a geometric progression from . This function is chosen by authors because they believe(hypothesized) this would allow the model to easily learn to attend by relative positions since for any fixed offset k, can be represented as a linear function of .

That’s all I know :) Thank you for reading!

References

1. http://jalammar.github.io/illustrated-transformer/ - An excellent overview of Transformer models.
2. https://kazemnejad.com/blog/transformer_architecture_positional_encoding/ - A detailed explanation of positional encodings.
3. https://arxiv.org/pdf/1409.0473.pdf - Neural Machine Translation by Jointly Learning to Align and Translate.
4. https://arxiv.org/abs/1706.03762v5 - Attention Is All You Need.

RNN Encoder-Decoder

Let’s look at the encoder-decoder architecture more formally.

Attention Mechanism: A new approach to Encoder-Decoder Structure

References

• Neural Machine Translation by Jointly Learning to Align and Translate

Why do we need Docker?

We have web servers, database services, messaging services, etc. and all of them have their dependencies(libraries, OS version, etc.) and there can be a conflict between them. We call it “The matrix from Hell”.

What does docker do?

Run each component in a separate, isolated environment with its dependencies and its libraries. All within the same VM or host.

What are the differences with VM?

VMs are complete isolation! They have their hardware, kernel, and OS. But docker containers use the same hardware and same Linux kernel.

That is the reason why you can’t have a Windows container. You can say: “Hey! I have a docker on windows!”. Then I say, look for WSL. 😄

Containers meant to run a specific task or process, not meant to host an OS.

Some Useful Docker Commands

1. docker version: It gives the docker version.
2. docker run: It is used to run a container from an image
   • docker run nginx ⇒ Runs instance of the Nginx application on the docker host
   • docker run -d nginx ⇒ Runs in the detached mode. That means the container will run in the background, and you can continue to use the terminal
   • docker run — name webapp nginx ⇒ Run a container with the given name
   • docker run -it nginx ⇒ “-i” gives stdin to docker, you can get input from the terminal. “-t” gives terminal so your dockerized app can print something
   • docker run -v /opt/datadir:/var/lib/mysql ….. ⇒ The container maps /var/lib/mysql(in docker) to /opt/datadir(in your pc). Your data will persist even when you delete the container.
   • docker run -p 80:5000 nginx ⇒ Forward your port 80 to container’s port 5000.

Note: You can’t bind the same host port to the multiple docker instances.

3. docker ps: List all running containers and several key information about them. If used with the “-a” parameter, you can see previously stopped or exited containers.

4. docker stop: It stops the running containers. Needs container ID or name.

   • docker stop silly_sammet

5. docker rm: Removes stopped or exited container permanently. If it prints the name back, we are good.

   • docker rm silly_sammet

6. docker images: Gives a list of downloaded images and their sizes.

7. docker rmi: Removes the given image. You need to remove all dependent containers before.

   • docker rmi nginx

8. docker pull: Just downloads the images so you won’t wait when you want to run the image.

9. docker exec: Execute a command in the container.

   • docker exec distracted_meclintock(container name) cat /etc/host(command)

10. docker inspect: It returns all details of the container in JSON format.

    • docker inspect webapp

11. docker logs: This shows the logs of a container. It is useful when your container runs in detached mode

Tags

For example “docker redis” command will run the latest Redis version for you. What if you want to use an older version of Redis?

docker run redis:4.0 bold part is the Tag of a container.

Where can I find tags of the docker image?

https://hub.docker.com

Environment Variables

In python, we access an environment variable like this:

os.environ.get(‘APP_COLOR’)

How can you set it in docker?

docker run -e APP_COLOR=pink web-app

How to create my own image?

Let’s say we have a webserver to run on an Ubuntu OS, what would be our steps to run it?

1. OS — Ubuntu
2. Update apt repo
3. Install dependencies using apt
4. Install Python dependencies using pip
5. Copy source code to ex. /opt folder
6. Run web server using ex. “flask” command

Then we need to do these steps in a file called Dockerfile.

FROM Ubuntu  
RUN apt-get update 
RUN apt-get install python  
RUN pip install flask 
RUN pip install flask-mysql  
COPY . /opt/source-code  
ENTRYPOINT FLASK_APP = /opt/source-code/app.py flask run

Let’s build our Dockerfile and have a docker image!

docker build -t nusret/chatbot "Address of the dockerfile without double quote"

And push it to the DockerHub if you want

docker push nusret/chatbot

What is this Dockerfile?

Dockerfile is a text file written in a specific format that docker can understand.

How can I export/import my docker image as a tar file?

You can export your Docker Image as a .tar file with this command:

docker save —output chatbot.tar nusret/chatbot

And you can easily import it with a very similar command.

docker load —input chatbot.tar

ENTRYPOINT VS CMD

Let’s say we have a docker container that just “sleeps” named “sleeper”. The docker file would be like this:

FROM Ubuntu  
CMD ["sleep","5"]

When I run the command:

docker run sleeper sleep 10

This CMD command will get replaced with sleep 10. But as this is a sleeper container, I could only say “10” and the container must sleep. To do this we change the dockerfile like this:

FROM Ubuntu  
ENTRYPOINT ["sleep"]

This time when I run:

docker run sleeper 10

The “10” will be appended to the “sleep” command and I can just set the sleep time. But what if I don’t write any number? How can I add a default sleep time?

FROM Ubuntu  
ENTRYPOINT ["sleep"]
CMD ["5"]

Docker Networking

1. Default network a container gets attached to. A bridged network is a private internal network created by docker on the host. All containers are attached to this network and have their internal IP addresses. Containers can access each other by using these internal IPs. If you want to access any of these containers from the outside world, you need to bind/forward the host’s port to the ports on the Docker network
2. Another way to access these containers is removing the network isolation between the docker host and the docker container by associating the container with the host’s network.
3. In the “none” network, the container is not attached to any network, and it is not accessible from external networks or any other docker containers.

Containers can access each other using their names. Docker creates a DNS server that helps containers using each other’s names.

Docker Compose

When we have a complex app that runs with multiple containers, we need to write lots of run commands! But we have docker-compose.

With the latest command at the bottom, you can run all of these images and more! We are using a .yaml file to configure docker-compose.

Let’s say we have a sample application like this:

What you would do without docker-compose:

docker run -d --name=redis redis 
docker run -d --name=db postgres:9.4 
docker run -d --name=vote -p 5000:80 --link redis:redis voting-app 
docker run -d --name=result -p 5001:80 --link db:db result-app 
docker run -d --name=worker --link db:db --link redis:redis worker

With docker-compose, you can write a docker-compose.yaml file like this:

redis:
  image: redis
db:
  image: postgres:9.4
vote:
  image: voting-app
  ports:
    - 5000:80
result:
  image: result-app
  ports:
    - 5001:80
worker:
  image: worker  

And run them all with a single command:

docker-compose up

What if some of the images are not already built or not in the DockerHub? Like the “voting-app” in our example, we can change the image key with a build key and specify a location of a directory that contains the application code and Dockerfile.

Change this code:

vote:
  image: voting-app
  ports:
    - 5000:80

To this:

vote:
  build: ./vote
  ports:
    - 5000:80

Docker Compose Versions

Docker-compose evolved over time and now supports a lot more options than it did in the beginning.

redis:
  image: redis
db:
  image: postgres:9.4
vote:
  image: voting-app
  ports:
    - 5000:80
  links:
    - redis

version: 2
services:
  redis:
    image: redis
  db:
    image: postgres:9.4
  vote:
    image: voting-app
    ports:
      - 5000:80
    depends_on:
      - redis

version: 3
services:
  redis:
    image: redis
  db:
    image: postgres:9.4
  vote:
    image: voting-app
    ports:
      - 5000:80

Networking in Docker Compose

Let us say we modify the architecture a little bit to contain the traffic from the different sources in separate networks. For example, we would like to separate the user-generated traffic from the application’s internal traffic. So, we create a front-end network dedicated to the traffic from users and a backend network dedicated to the traffic within the application.

This is the .yaml file you need to write:

version: "3"
services:
  redis:
    image: redis
    networks:
      - back-end
  db:
    image: postgres:9.4
    networks:
      - back-end
  vote:
    image: voting-app
    ports:
      - "5000:80"
    networks:
      - front-end
      - back-end
  result:
    image: result-app
    ports:
      - "5001:80"
    networks:
      - front-end
      - back-end
  worker:
    image: worker
    networks:
      - front-end
      - back-end

networks:
  front-end:
    driver: bridge
  back-end:
    driver: bridge

So, that’s it! Please watch the video from FreeCodeCamp’s channel to get more detailed information. Also, take a look at the KodeKlaud’s channel!