| --- |
| language: |
| - en |
| pipeline_tag: text-generation |
| tags: |
| - Python |
| - assistant |
| - code |
| --- |
| |
| TLDR; |
| - Updated to V2: |
| - Now it can deal with Leetcode problems, (still far from being perfect, check the example). |
| - The model is quite fun to play with as it seems pretty competent: |
| - It's much better than bigger general models but not perfect. |
| - It shows a good understanding about coding: |
| - It can correct itself or improve the code if asked for it. |
| - It has a good knowledge about Python and Python libraries: |
| - You can for example, ask the model to create a tutorial about some python library. |
| - Getting what you want from the model can be a hit or miss: |
| - Sometimes you'll have to fight extensively with the way you write the prompt to get what you want. |
| - Sometimes you won't be able to make the model do what you want. |
|
|
| --------------------------------------------------------------- |
|
|
| ### Objective: |
| This is a proof of concept to see how far LLM's on the smaller side can go when fine-tuned for code generation and understanding. |
|
|
| ### Foundation: |
| The base model is based on OpenLlama-3b and can be found [here](https://huggingface.co/psmathur/orca_mini_3b) and it has been fine-tuned with LoRA using [axolotl](https://github.com/OpenAccess-AI-Collective/axolotl/tree/main). |
| Unlike the base model the prompt is based on Alpaca. |
|
|
| ### Examples: |
| Next there are some examples to show what the model is currently capable of. |
| (I have edited the quotes to be able to show the prompts correctly here the model outputs proper markdown.) |
|
|
| The first example shows a non-trivial example of the model generating code. |
| (Depending on the complexity of the required task the generated code might not work. For example, making the model write code to move the square |
| around has proven to be quite difficult, the latest version can produce valid code for this.) |
| ``` |
| Below is an instruction that describes a task. Write a response that appropriately completes the request. |
| |
| ### Instruction: |
| Write Python code to draw a square on the screen using Pygame. |
| |
| ### Response: |
| Sure, here's a Python code to draw a square on the screen using PyGame. |
| '''python |
| import pygame |
| |
| pygame.init() |
| window = pygame.display.set_mode((800, 600)) |
| |
| def draw(x, y): |
| pygame.draw.rect(window, (255, 170, 170), [x, y, 50, 50]) |
| |
| running = True |
| while running: |
| for event in pygame.event.get(): |
| if event.type == pygame.QUIT: |
| running = False |
| |
| # Clear the screen |
| window.fill((0, 0, 0)) |
| |
| # Draw a square |
| x, y = 40, 30 |
| draw(x, y) |
| |
| # Update the display |
| pygame.display.flip() |
| ''' |
| ``` |
|
|
| Next there are a few samples to show how the model understands the code. |
| In this first example the model is able to answer correctly what shape is being drawn and even tells the position correctly, it gets the color wrong in this case |
| ``` |
| Below is an instruction that describes a task. Write a response that appropriately completes the request. |
| |
| ### Instruction: |
| What shape does the following code draw on the screen? |
| import pygame |
| |
| pygame.init() |
| window = pygame.display.set_mode((800, 600)) |
| |
| def draw(x, y): |
| pygame.draw.rect(window, (255, 170, 170), [x, y, 50, 50]) |
| |
| running = True |
| while running: |
| for event in pygame.event.get(): |
| if event.type == pygame.QUIT: |
| running = False |
| |
| # Clear the screen |
| window.fill((0, 0, 0)) |
| |
| # Draw a square |
| x, y = 40, 30 |
| draw(x, y) |
| |
| # Update the display |
| pygame.display.flip() |
| |
| ### Response: |
| The code will draw a red square at position (40, 30). |
| ``` |
|
|
| To the question about how to improve the code the model answers by adding code to limit the number of frames per second. |
| ``` |
| Below there are some samples generated by the model: |
| Below is an instruction that describes a task. Write a response that appropriately completes the request. |
| |
| ### Instruction: |
| How could you improve the following code? |
| |
| '''python |
| import pygame |
| from pygame.locals import * |
| |
| pygame.init() |
| window = pygame.display.set_mode((800, 600)) |
| |
| def main(): |
| done = False |
| |
| while not done: |
| for event in pygame.event.get(): |
| if event.type == QUIT: |
| done = True |
| |
| # Clear the screen |
| window.fill((0, 0, 0)) |
| |
| # Draw the square |
| x, y = 150, 140 |
| pygame.draw.rect(window, (255, 0, 0), [x, y, 50, 50]) |
| |
| # Update the display |
| pygame.display.flip() |
| |
| if __name__ == '__main__': |
| main() |
| ''' |
| |
| ### Response: |
| You can use `pygame.time.Clock` to control the frames per second and limit the number of frames to prevent your program from freezing. Here's a modified version of your code with this addition: |
| |
| '''python |
| import pygame |
| from pygame.locals import * |
| |
| pygame.init() |
| window = pygame.display.set_mode((800, 600)) |
| clock = pygame.time.Clock() |
| |
| def main(): |
| done = False |
| |
| targetFPS = 30 |
| currentFPS = clock.tick(targetFPS) / targetFPS |
| maxFrames = int(currentFPS * 60) + 1 |
| while not done: |
| for event in pygame.event.get(): |
| if event.type == QUIT: |
| done = True |
| |
| # Limit frames to targetFPS |
| if currentFPS > targetFPS: |
| currentFPS = targetFPS |
| maxFrames = min(maxFrames, targetFPS * 60) |
| |
| # Clear the screen |
| window.fill((0, 0, 0)) |
| |
| # Draw the square |
| x, y = 150, 140 |
| pygame.draw.rect(window, (255, 0, 0), [x, y, 50, 50]) |
| |
| # Update the display |
| pygame.display.flip() |
| |
| if __name__ == '__main__': |
| main() |
| ''' |
| ``` |
|
|
| Finally an easy leetcode problem. The latest version of the model can solve the problem (with a O(n^2) solution). |
| Given the implementation it shouldn't be hard for the model to turn nums into a set and get the O(n) solution, but |
| it's always a game of try and error. |
| ``` |
| Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request. |
| |
| ### Instruction: |
| Solve the following problem using Python 3. Write only the code. |
| |
| ### Input: |
| Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target. |
| |
| You may assume that each input would have exactly one solution, and you may not use the same element twice. |
| |
| You can return the answer in any order. |
| |
| |
| Example 1: |
| |
| Input: nums = [2,7,11,15], target = 9 |
| Output: [0,1] |
| Explanation: Because nums[0] + nums[1] == 9, we return [0, 1]. |
| |
| Example 2: |
| |
| Input: nums = [3,2,4], target = 6 |
| Output: [1,2] |
| |
| Example 3: |
| |
| Input: nums = [3,3], target = 6 |
| Output: [0,1] |
| |
| |
| |
| Constraints: |
| |
| 2 <= nums.length <= 10^4 |
| -10^9 <= nums[i] <= 10^9 |
| -10^9 <= target <= 10^9 |
| Only one valid answer exists. |
| |
| |
| |
| ### Response: |
| Certainly, here is a potential way to implement a program in Python that addresses the problem at hand. |
| '''python |
| class Solution: |
| def twoSum(self, nums: List[int], target: int) -> List[int]: |
| l = [] |
| for i in range(len(nums)): |
| if target-nums[i] in l: |
| return [l.index(target-nums[i]), i] |
| else: |
| l.append(nums[i]) |
| return [-1,-1] |
| ''' |
| ``` |
