【CodeGemma】GoogleのGemmaをコーディングタスクに特化させたLLMの使い方

pip install transformers accelerate

from transformers import GemmaTokenizer, AutoModelForCausalLM

#実装したモデルを指定
tokenizer = GemmaTokenizer.from_pretrained(
    "google/codegemma-7b"
)
model = AutoModelForCausalLM.from_pretrained(
    "google/codegemma-7b",
    device_map="auto",
    torch_dtype="auto",
)

prompt = '''\
<|fim_prefix|>import datetime
def calculate_age(birth_year):
    """Calculates a person's age based on their birth year."""
    current_year = datetime.date.today().year
    <|fim_suffix|>
    return age<|fim_middle|>\
'''

inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
prompt_len = inputs["input_ids"].shape[-1]
outputs = model.generate(**inputs, max_new_tokens=100)
print(tokenizer.decode(outputs[0][prompt_len:]))

input_text = "Write me a Python function to calculate the nth fibonacci number."
input_ids = tokenizer(input_text, return_tensors="pt")

outputs = model.generate(**input_ids)
print(tokenizer.decode(outputs[0]))

age = current_year - birth_year<|file_separator|>test_calculate_age.py
<|fim_suffix|>
    assert calculate_age(1990) == 33
    assert calculate_age(2000) == 23
    assert calculate_age(1985) == 38
    assert calculate_age(1995) == 28
    assert calculate_age(1975) == 48

Answer:

Step 1/2
def fibonacci(n):

Step 2/2
if n == 0: return 0 elif n == 1: return 1 else: return fibonacci(n-1) + fibonacci(n-2)<eos>

Generate a program that translates English text into Japanese and even performs morphological analysis.

A program should provide the following features:


1. Text input and output.
2. Language selection.
3. Translation and morphological analysis.
4. Error handling and message reporting.
5. Control of translation and analysis options.
Note: This program requires the following Python libraries: morfessor, deepcut, googletrans.


import googletrans
from morfessor import Morphosynthesizer, MorphAnalyzer
from deepcut import Deepcut

# Initialize translation and analysis tools
translator = googletrans.Translator()
synthesizer = Morphosynthesizer()
analyzer = MorphAnalyzer(language="en")

# Define functions for translation and analysis
def translate_text(text, source_lang, target_lang):
    translation = translator.translate(text, src=source_lang, dest=target_lang)
    return translation.text

def analyze_text(text):
    tokens = Deepcut.tokenize(text)
    tokens = analyzer.analyze(tokens)
    return tokens

# Main program loop
while True:
    # Get user input
    text = input("Enter text to translate (or 'q' to quit): ")
    if text == "q":
        break

    # Set language options
    source_lang = input("Enter source language (en/jp): ")
    target_lang = input("Enter target language (en/jp): ")

    # Translate and analyze text
    translation = translate_text(text, source_lang, target_lang)
    analysis = analyze_text(translation)

    # Print results
    print("Translation:", translation)
    print("Morphological analysis:", analysis)
Usage:

Install the required Python libraries.
Run the program.
Enter text to translate (or "q" to quit).
Select the source and target languages.
The program will translate the text and perform morphological analysis.
The results will be printed.
Note:

The program supports English and Japanese languages.
The morphological analysis is performed on the translated text.
The translation quality may vary depending on the source and target languages.
The analysis results may be incomplete or inaccurate for complex sentences.

Creating a program that translates English text into Japanese and performs morphological analysis is a complex task that involves several steps and requires the use of specific libraries. Here's a Python program that uses the googletrans library for translation and the nagisa library for morphological analysis:


import nagisa
from googletrans import Translator

# Initialize the translator
translator = Translator()

def translate_to_japanese(text):
    """
    Translates English text to Japanese using the Google Translate API.
    """
    translated = translator.translate(text, dest='ja')
    return translated.text

def perform_morphological_analysis(text):
    """
    Performs morphological analysis on Japanese text using the Nagisa library.
    """
    tokens = nagisa.tokenize(text, eos=False, kana=False)
    pos_tags = nagisa.tagging(tokens)
    morphological_analysis = []
    
    for token, pos_tag in pos_tags:
        morphological_analysis.append(f"{token}: {pos_tag}")
    
    return morphological_analysis

def main():
    # User input
    english_text = input("Enter English text: ")
    
    # Translation to Japanese
    japanese_text = translate_to_japanese(english_text)
    print(f"Japanese translation: {japanese_text}")
    
    # Morphological analysis
    morphological_analysis = perform_morphological_analysis(japanese_text)
    print("Morphological analysis:")
    for result in morphological_analysis:
        print(result)

if __name__ == "__main__":
    main()
To use this program, you'll need to install the googletrans and nagisa libraries. You can install them using pip:


pip install googletrans==4.0.0-rc1 nagisa
Please note that the googletrans library uses the Google Translate API, which has usage limits and may require an API key for higher usage. The nagisa library is a simple and fast library for Japanese morphological analysis.

Keep in mind that this program may not always provide perfect translations or morphological analysis, as natural language processing is a complex task. It's always a good idea to double-check the results for accuracy.

Creating a program that translates English text into Japanese and performs morphological analysis involves multiple steps, including using libraries for translation and morphological analysis. Here’s how you can build a basic version of such a program in Python using `googletrans` for translation and `mecab-python3` for morphological analysis.

### Step 1: Install Necessary Libraries

You'll need to install the following Python libraries. `googletrans` is used for translation, and `mecab-python3` is used for morphological analysis:

```bash
pip install googletrans==4.0.0-rc1
pip install mecab-python3
```

### Step 2: Sample Program

Here's a simple Python script that combines these tools. This script translates English text into Japanese and then analyzes the morphological components of the translated text:

```python
from googletrans import Translator
import MeCab

# Initialize translator and MeCab
translator = Translator()
tagger = MeCab.Tagger()

def translate_and_analyze(text):
    # Translate text from English to Japanese
    translation = translator.translate(text, src='en', dest='ja')
    translated_text = translation.text
    print("Translated Text:", translated_text)
    
    # Perform morphological analysis on the translated Japanese text
    print("Morphological Analysis:")
    print(tagger.parse(translated_text))

# Example usage
input_text = "The quick brown fox jumps over the lazy dog."
translate_and_analyze(input_text)
```

### Explanation:
1. **Translation**: The `Translator` object from `googletrans` library translates the input English text into Japanese.
2. **Morphological Analysis**: The `MeCab.Tagger` object analyzes the Japanese text to break it down into morphemes, showing their respective parts of speech and other linguistic features.

### Important Notes:
- **Library Versions**: The `googletrans` library version specified (4.0.0-rc1) is known to be stable as of my last update, but you should check for the latest stable versions or alternatives if you encounter issues.
- **Accuracy and Limitations**: While `googletrans` uses Google Translate's web API unofficially, it might not be reliable for production use due to potential API changes. For professional or frequent usage, consider using the official Google Cloud Translation API.
- **MeCab Configuration**: `MeCab` is a powerful library for Japanese language processing, but it may require additional configuration (like dictionary path settings) depending on your system's setup and the specific requirements of your application.

This script provides a basic demonstration of translation and morphological analysis. For more complex applications, you may need to expand or modify this setup, especially to handle larger texts, maintain API usage limits, or ensure more robust error handling.

Create a program in C to classify the entered amount of money by type of money

#include <stdio.h>

int main() {
    int amount;

    // Get the amount of money from the user
    printf("Enter the amount of money: ");
    scanf("%d", &amount);

    // Check the amount of money
    if (amount >= 1000) {
        printf("The money is a large amount.\n");
    } else if (amount >= 500) {
        printf("The money is a medium amount.\n");
    } else {
        printf("The money is a small amount.\n");
    }

    return 0;
}

Here is a simple program in C that classifies the entered amount of money by type (cash, credit card, or debit card). This program only serves as a basic example and can be expanded upon to include more accurate classification based on specific conditions.


#include <stdio.h>

int main() {
    float money;

    printf("Enter the amount of money: ");
    scanf("%f", &money);

    if(money <= 0) {
        printf("Invalid amount. Please enter a positive value.\n");
        return 1;
    }

    if(money < 1000) {
        printf("This is small cash.\n");
    } else if(money < 5000) {
        printf("This is credit card payment.\n");
    } else {
        printf("This is a debit card payment.\n");
    }

    return 0;
}
This program asks the user to input an amount of money, then it checks if the amount is less than 1000, between 1000 and 5000, or more than 5000. Based on these conditions, it prints out the type of money.

Remember, this is a very basic example. For a real-world application, you would likely need to consider additional factors, such as currency type (US dollars, Euros, etc.), transaction frequency, account balance, payment method (not only credit/debit cards, but also online payments, mobile payments, etc.), and many others.

Also, note that this program does not handle errors related to input, such as non-numeric input or negative numbers. You might want to add error checking code to handle such situations according to your specific requirements.

Creating a simple C program to classify an entered amount of money by type can be a fun way to practice basic programming skills. This program will ask the user to enter an amount in a specific currency (for simplicity, let's use dollars), and it will then break down this amount into different denominations (e.g., 20s, 10s, 5s, and 1s).

Here's a simple example of how such a program could look:

```c
#include <stdio.h>

int main() {
    int amount, twenties, tens, fives, ones;

    printf("Enter an amount in dollars: ");
    scanf("%d", &amount);

    twenties = amount / 20; // Calculate the number of 20 dollar bills
    amount = amount % 20; // Update the amount with the remainder

    tens = amount / 10; // Calculate the number of 10 dollar bills
    amount = amount % 10; // Update the amount with the remainder

    fives = amount / 5; // Calculate the number of 5 dollar bills
    amount = amount % 5; // Update the amount with the remainder

    ones = amount; // The remainder are 1 dollar bills

    printf("Your amount includes:\n");
    printf("%d Twenty dollar bills\n", twenties);
    printf("%d Ten dollar bills\n", tens);
    printf("%d Five dollar bills\n", fives);
    printf("%d One dollar bills\n", ones);

    return 0;
}
```

To run this program, you'll need to compile it with a C compiler like GCC. Here's how you might do that:

```bash
gcc -o money_classifier money_classifier.c
./money_classifier
```

This assumes you've saved the code in a file named `money_classifier.c`. When you run the program, it will prompt you to enter an amount in dollars, and it will then break down that amount into 20s, 10s, 5s, and 1s, printing out how many of each type of bill the entered amount equates to.

This program is a basic example and does not handle input errors or amounts in coins for simplicity. Expanding this program to include coin denominations or to handle input errors could be good practice for further learning.